lgastako

{-# LANGUAGE OverloadedStrings #-}

module GetIn where

import Data.Aeson          ( Value( Array
                                  , Null
                                  , Object
                                  )
                           , decode
                           )

lgastako

import qualified Data.Set as Set

type Row = Int
type Col = Int

renderSols :: [[(Row, Col)]] -> IO ()
renderSols = mapM_ (putStrLn . renderQs . Set.fromList)
  where
    renderQs queens = unlines $ map renderRow (range maxRow)
      where

lgastako

{-# LANGUAGE DeriveGeneric    #-}
{-# LANGUAGE OverloadedLabels #-}

module SideEffectsExample where

import Control.Lens
import Control.Monad
import Control.Monad.IO.Class
import Control.Monad.Trans.State.Lazy
import Data.Generics.Labels

lgastako

module Scrabble where

import           Data.List              ( sortOn )
import           Data.Map.Strict        ( Map )
import qualified Data.Map.Strict as Map
import           System.IO              ( hFlush
                                        , stdout
                                        )

main :: IO ()

lgastako

{-# LANGUAGE InstanceSigs         #-}
{-# LANGUAGE LambdaCase           #-}
{-# LANGUAGE NoImplicitPrelude    #-}
{-# LANGUAGE ScopedTypeVariables  #-}
{-# LANGUAGE StandaloneDeriving   #-}
{-# LANGUAGE TypeSynonymInstances #-}

module ParsingFromScratch where

import Data.String ( String )

lgastako

module MonadPoker where

-- https://old.reddit.com/r/haskell/comments/gru0id/haskell_poker_foldm_monadrandom/

import Control.Monad
import Control.Monad.Random
import System.Random.Shuffle

data Rank
  = Two

lgastako

{-# LANGUAGE RankNTypes          #-}
{-# LANGUAGE ScopedTypeVariables #-}

module Data.Matrix.Lens
  ( col
  , diag
  , elemAt
  , inverted
  , minor
  , row

lgastako

module TreeNumbering where

import Control.Lens
import Control.Monad.State
import Data.Tree

tree_ :: Tree Char
tree_ = Node 'd'
  [ Node 'b'
    [ Node 'a' []

lgastako

words'' :: String -> [String]
words'' s
  | s == "" = []
  | otherwise = takeWhile (/= ' ') s : words'' (dropWhile (== ' ') (dropWhile (/= ' ') s))

words' :: String -> [String]
words' s
  | w /= ""   = w : words' rest
  | otherwise = []
  where

lgastako

{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE OverloadedStrings #-}

module Fizz where

import Protolude

fizzBuzz :: IO ()
fizzBuzz = run fizzBuzzRules