Haskell is really a mindblowing game :)

Author: ZeppLu

README.md

@@ -15,6 +15,8 @@
   **TODO**.
 - [What I Wish I Know When Learning Haskell](http://dev.stephendiehl.com/hask),
   **TODO**.
+- [CS240H: Functional Systems in Haskell](http://www.scs.stanford.edu/16wi-cs240h),
+  **TODO**.
 
 
 ### Random explorations

lyh04.hs

@@ -31,3 +31,12 @@ howLong xs = "This list is " ++ long xs ++ " long"
           long [_]    = "one"
           long [_, _] = "two"
           long _      = "too"
+-- Since `case' is an expression, doing so is also fine,
+-- despite its less readability
+howLong' xs = "This list is " ++
+                  case xs of
+                      []     -> "zero"
+                      [_]    -> "one"
+                      [_, _] -> "two"
+                      _      -> "too"
+                  ++ " long"

lyh06.hs

@@ -30,6 +30,8 @@ merge = map (\(a, b) -> a + b)
 sum' :: Num a => [a] -> a
 sum' = foldl (+) 0
 elem' x xs = foldl (||) False (zipWith (==) (repeat x) xs)
+-- A possibly clearer method
+elem'' x xs = any (==x) $ xs
 -- `map' can also built upon `foldl', but it requires `++',
 -- which it much more expansive than `:'
 map' f xs = foldr applyNew [] xs

rwh04.hs

@@ -0,0 +1,75 @@
+-- RWH Chapter 4. Functional programming --
+
+import Control.Exception (assert)
+
+-- Better to use `null' than `length', because of the lazy evaluation
+-- Or, pattern matching is also a good idea (which actually resembles
+-- what `null' does, so less readable)
+-- This sucks on infinite lists, also decrease performance on long lists
+safeHeadDumb xs = if length xs > 0
+                  then Just $ head xs
+                  else Nothing
+safeHead xs
+    | null xs   = Nothing
+    | otherwise = Just $ head xs
+safeHead' [] = Nothing
+safeHead' xs = Just $ head xs
+
+-- Partial / total functions (think of `totality' in Idris)
+
+-- `and', `or', `all', `any' on empty list
+-- Be careful! Assertion is done when you need its value!
+andEmpty = assert (and      []) True
+orEmpty  = assert (not $ or []) False
+
+
+
+-- Failed to get a reasonably working `zipWithN'
+-- Further readings:
+-- * http://okmij.org/ftp/Haskell/polyvariadic.html
+-- * https://stackoverflow.com/questions/20558648/what-is-the-datakinds-extension-of-haskell
+-- * https://www.reddit.com/r/haskell/comments/b9qyp/generalized_zipwithn_with_a_pretty_implementation/
+
+{-
+--data Z
+--data S n
+
+class NatureNum a where
+    fromNum :: Integral b => b -> a
+    toNum   :: Integral b => a -> b
+
+--data Nat n where
+--    Zero :: Nat Z
+--    Succ :: Nat n -> Nat (S n)
+data Nat = Z | S Nat
+
+--instance NatureNum (Nat) where
+--    toNum  Z    = 0
+--    toNum (S n) = 1 + toNum n
+
+--instance NatureNum Zero where
+--    fromNum _ = Zero
+--    toNum   _ = 0
+--instance NatureNum (Succ n) where
+--    fromNum _ = Succ Zero
+--    toNum   _ = 1
+
+--fromNum :: Integral a => a -> (Nat n)
+--fromNum 0 = Zero
+----fromNum k = Succ ( fromNum (k-1))
+--fromNum 1 = Succ Zero
+
+
+--data NArgsFunc a :: Nat -> * where
+--    NArgsFunc :: 
+
+--data NArgsFunc a = ZeroArgFunc a
+--                 | NArgsFunc a (NArgsFunc a)
+
+type ZeroArgFunc a = a
+testZ :: (ZeroArgFunc Int)
+testZ = (42)
+type NArgsFunc Nat a = a -> (NArgsFunc Z 
+test1 :: (NArgsFunc [Char] (ZeroArgFunc Int))
+test1 = length
+-}