pages tagged haskell

Haskell

Sat, 13 Oct 2018 03:56:52 +0000

Journal

Entering multi-line code in GHCi

Use :{ and :} to sandwich a block of code consisting of multiple lines:

Prelude> :{
Prelude| incrementInteger :: Int -> Int
Prelude| incrementInteger x = x + 1
Prelude| :}
Prelude> incrementInteger 1
2

Using the latest released version of GHC with stack

Specify the version of LTS (i.e. Long Term Support) Haskell to use by default in `$HOME/.stack/global-project/stack.yaml:

resolver: lts-8.15

As of May, 2017, the newest released version of LTS Haskell is 8.15. This version number can be found on https://www.haskell.org/downloads.

`data`, `type`, and `newtype`

https://stackoverflow.com/a/33316715

In GHCi, print the type of a symbol

  Prelude> :type Nothing
  Nothing :: Maybe a
  Prelude> :type (+)
  (+) :: Num a => a -> a -> a
  Prelude> :type print "Hello World"
  print "Hello World" :: IO ()

`Nothing` and `Maybe`

Partial application

Functions are not partial, but rather a function can be applied partially.

Function type decalaration

myFunc :: type1 -> type2 -> type3 -> type4

Pure as in 'pure functional programming languages'

Get information about a Haskell word in GHCi

Prelude> :info pure
class Functor f => Applicative (f :: * -> *) where
  pure :: a -> f a
  ...
    -- Defined in ‘GHC.Base’

Concatenating multiple strings into one using `intercalate`, `intersperse` and `concat`, and `unword`.

Function application takes precedence over any binary operator.

For example,

ourPicture = colored green (solidCircle 1) & solidCircle 2

is equivalent to

ourPicture = (colored green (solidCircle 1)) & (solidCircle 2)

Changing a prefixing function to an infix binary operator

Prelude> mod 3 2
1
Prelude> 3 `mod` 2
1

Largest integer

Prelude> :{
Prelude| myInt :: Int
Prelude| myInt = 2^63 - 1
Prelude| :}
Prelude> myInt
9223372036854775807
Prelude> myInt + 1
-9223372036854775808

Prelude> :{
Prelude| minInt :: Int
Prelude| minInt = - 2^63
Prelude| :}
Prelude> minInt
-9223372036854775808
Prelude> minInt - 1
9223372036854775807

Arithmetic expression with different types of numbers

Prelude> :{
Prelude| d :: Double
Prelude| i :: Int
Prelude| d = 1.2
Prelude| i = 1
Prelude| :}
Prelude> d+i

<interactive>:48:3: error:
    • Couldn't match expected type ‘Double’ with actual type ‘Int’
    • In the second argument of ‘(+)’, namely ‘i’
      In the expression: d + i
      In an equation for ‘it’: it = d + i
Prelude> d + fromIntegral i
2.2
Prelude>

References

https://www.stackage.org
- Lookup basic information about a word, e.g. pure: https://www.stackage.org/lts-8.15/hoogle?q=pure

Haskell

Sat, 13 Oct 2018 03:56:52 +0000

Misc

http://tryhaskell.org

Softwares

IDE's

http://code.world/haskell, an online IDE to write and run Haskell code, e.g. https://code.world/haskell#Ptxn0dmOwm9z1xqIGrwPfzQ.

Haskell and Wolfram Language syntax comparison

Fri, 19 May 2017 02:50:12 +0000

description	Haskell	Wolfram	comment
defining a named function with explicitly named arguments	`incrementInteger :: Int -> Int incrementInteger n = n + 1`	`incrementInteger[n_Integer] := n + 1;`
defining a named function with lambda expression	`incrementInteger :: Int -> Int incrementInteger = \n -> n + 1`	`incrementInteger = Function[{n}, n + 1];`
defining a function with a function name as one of the arguments	`Prelude> increment = \x -> x+1 Prelude> double = \x -> 2*x Prelude> thenDouble someFunc = double . someFunc Prelude> thenDouble increment 3 8`	`In[1]:= double = Function[x, 2x]; increment = Function[x, x + 1]; thenDouble[someFunc_] := Composition[double, someFunc]; In[4]:= thenDouble[increment] Out[4]= Function[x, 2 x]@Function[x, x + 1] In[5]:= (thenDouble[increment])[3] Out[5]= 8`
defining a function with locally definded intermediate functions	`Prelude> :{ Prelude> myFunc1 x = Prelude> let y = sin x Prelude> in cos y Prelude> :} Prelude> myFunc1 pi 1.0 Prelude> :{ Prelude> myFunc2 x = Prelude> cos y Prelude> where Prelude> y = sin x Prelude> :} Prelude> myFunc2 pi 1.0`	`In[1]:= myFunc[x_]:=With[{f=Sin[x]},Cos[f]] myFunc[Pi] Out[2]= 1`	Alternatively, instead of using `With` (for symbolic replacement), use `Module` (for lexical scoping) or `Block` (for dynamic scoping).

《Learn You a Haskell for Great Good!》 study note

Thu, 18 May 2017 23:35:08 +0000

Introduction

Haskell is a purely functional programming language.
"In purely functional programming you don't tell the computer what to do as such but rather you tell it what stuff is. … You express that in the form of functions. … "
A Haskell function cannot have side effects other than mapping its input to an output as a mathematical function.
Haskell is lazy in that it does not compute anything until it have to in order to return a value.
Haskell is statically typed.
- Type inference allows deducing the appropriate type automatically by inference on compatibility between the inputs and outputs.

Starting out

Ready, set, go!

ghci: The Glorious Glasgow Haskell Compilation System. Environment to interactively compile and run Haskell programs. Exit GHCi using :quit. GHCi documentation.
Not-equal operator: /=.
Compile-time error on incompatible types: 123 + "foobar"
Compile a program: ghci> l:myprogram.hs.
' is allowed in function name, e.g. foo'Bar is a valid function name.
Function names cannot begin with a lower-case letter.

An intro to lists

In Haskell, a strings is a lists of characters.
List and tuple syntax difference: [1, 2], (1, "foobar"). A tuple can contain elements of different types, while a list cannot. This bears some similarity with Python's lists and tuples. A difference is that in Python, lists are mutable but tuples are not.
Concatenate operation: [1, 2] ++ [3, 4], "foo" ++ "bar", ['a', 'b'] ++ ['c', 'd'].

[https://en.wikipedia.org/wiki/Cons cons] operation ::

  Prelude> 'f' : "bar"
  "fbar"
  Prelude> 1: [3, 4]
  [1,3,4]
  Prelude>

If "XXX...XXX" is a very long string, "XXX...XXX" ++ "foobar" will be slow.
[1, 2, 3] equals 1 : 2 : 3 : [].
Take parts of a list: [1, 3, 5, 7] !! 2 returns 5. Haskell lists uses zero-based numbering. take 2 [1, 3, 5, 7] gives the third element 5. drop 2 [1, 3, 5, 7] gives [1, 3, 7]. Compare this to Mathematica {1,3,5,7}<span class="createlink">3</span>, Take[{1,3,5,7}, {3}], Drop[{1,3,5,7}, {3}].
Test element membership in a list: elem 3 [2, 4, 6] and 2 \elem` [1, 3, 5, 7]`.
[[1, 2], ["foo", "bar"]] is invalid as the types of the elements of the two sub-lists are not same.
Lists compare in lexicographical order. E.g. [1, 3, 4] < [1, 4, 2].
head [1, 2, 3], tail [1, 2, 3], init [1, 2, 3], last [1, 2, 3]. Compare with Mathematica / Wolfram Langauge namings: First[{1,2,3}], Rest[{1,2,3}], Most[{1,2,3}], Last[{1,2,3}]
null [1, 2, 3], null []

Other side notes

One of the key features and advantanges of Haskell is its purity: all side-effects are encapsulated in a monad.
[https://en.wikipedia.org/wiki/Algebraic_data type Algebraic data type]:

data List a = Nil | Cons a (List a)

data Tree = Empty | Leaf Int | Node Tree Tree

Tree is a sum data type a.k.a. tagged union.

Tree is a recursive data type.

Pattern matching in Haskell:

  depth :: Tree -> Int
  depth Empty = 0
  depth (Leaf n) = 1
  depth (Node l r) = 1 + max (depth l) (depth r)

References

https://ghcformacosx.github.io/
Search a Haskell function by desired type signature, e.g. https://www.haskell.org/hoogle/?hoogle=String+-%3E+Int (And the desired function for turning an object to a String is possibly read :: Read a => String -> a).

Installing and configuring Haskell

Tue, 16 May 2017 23:59:39 +0000

`cabal` VS. `stack`

cabal and stack are two tools one can use to install Glasgow Haskell Compiler (GHC), i.e. the binaries ghc and ghci, and Haskell software packages. stack installs Haskell programs in ~/.stack and cabal installs in ~/.cabal. Using both cabal and stack, or either one of them is possible, but it seems the current general wisdom is that stack is more user friendly especially for beginners. So I chose to uninstall cabal and delete ~/.cabal, and use stack only.

Install Haskell compiler and softwares using `stack`

stack is built on top of cabal (which in turn relies on ghc-pkg), the package management system for Haskell softwares, but is more user friendly in some ways.

Uninstall the ghc installed using the system's package management system

macOS:

    brew uninstall --force cabal-install
    brew uninstall --force ghc

Linux:

    sudo apt-get remove ghc
    sudo apt-get remove cabal-install

Install stack
- macOS:
```
    brew install haskell-stack
```
- Linux: Follow the instruction about installation in the official documentation. Don't just do sudo apt-get install haskell-stack.
Install ghc
```
  stack setup
```
If you want to use binaries installed via stack regularly, put them on path. Run stack path and append the paths of form ~/.stack/.../bin in the output to $PATH in ~/.bashrc.

Install packages using stack:

  stack install ghc-mod
  stack install cabal-install
  stack install hlint
  stack install pandoc
  stack install purescript
  stack install wreq
  stack install lens
  stack install ihaskell        
  stack install projectile
  stack install use-package
  stack install which-key

  stack install apply-refact
  stack install codex
  stack install hasktags

ihaskell: IHaskell, Haskell kernel for Jupyter notebooks.

Install Haskell compiler and softwares using `cabal`

Install ghc and cabal
```
  brew install cabal-install ghc
```

Install packages via cabal

  cabal update
  cabal install happy # 2016-3-5: prerequisite for ghc-mod
  cabal install ghc-mod hlint haskell-docs

Verifying the stack and Haskell installation

cd $HOME
# Assume 'stack setup' has been run.
stack init
stack build --dependencies-only --test

Configure Emacs for Haskell development

Install the following Emacs packages, ideally using the GNU Emacs Lisp Package Archive (see also EmacsWiki: ELPA):

Emacs packages specifically relevant for Haskell:
- haskell-mode
- haskell-snippets
- flycheck-hlint
- intero
Other Emacs packages generally helpful.

Configure a Haskell project using `stack`

Create a project

cd path/to/workspace/
stack new haskell-stack-test-project
cd haskell-stack-test-project
stack setup
stack build --dependencies-only --test

This creates a new project using template ~/.stack/templates/new-template.hsfiles. The project directory structure:

$ tree
.
├── LICENSE
├── Setup.hs
├── app
│   └── Main.hs
├── haskell-stack-test-project.cabal
├── src
│   └── Lib.hs
├── stack.yaml
└── test
    └── Spec.hs

Remarks:

app/ contains the source file(s) for more application-specific logic, including a app/Main.hs.
src/ contains the source file(s) for more shareable and general-purpose code.

Build

$ cd path/to/haskell-stack-test-project
$ stack build
haskell-stack-test-project-0.1.0.0: configure
Configuring haskell-stack-test-project-0.1.0.0...
haskell-stack-test-project-0.1.0.0: build
Preprocessing library haskell-stack-test-project-0.1.0.0...
[1 of 1] Compiling Lib              ( src/Lib.hs, .stack-work/dist/x86_64-osx/Cabal-1.22.5.0/build/Lib.o )
In-place registering haskell-stack-test-project-0.1.0.0...
Preprocessing executable 'haskell-stack-test-project-exe' for
haskell-stack-test-project-0.1.0.0...
[1 of 1] Compiling Main             ( app/Main.hs, .stack-work/dist/x86_64-osx/Cabal-1.22.5.0/build/haskell-stack-test-project-exe/haskell-stack-test-project-exe-tmp/Main.o )
Linking .stack-work/dist/x86_64-osx/Cabal-1.22.5.0/build/haskell-stack-test-project-exe/haskell-stack-test-project-exe ...
haskell-stack-test-project-0.1.0.0: copy/register
Installing library in
/Users/meng/Dropbox/WorkSpace-Dropbox/Computing/repo-meng-lib/Haskell/haskell-stack-test-project/.stack-work/install/x86_64-osx/lts-5.5/7.10.3/lib/x86_64-osx-ghc-7.10.3/haskell-stack-test-project-0.1.0.0-BCjrGi4SAkj4MdkT4tD42y
Installing executable(s) in
/Users/meng/Dropbox/WorkSpace-Dropbox/Computing/repo-meng-lib/Haskell/haskell-stack-test-project/.stack-work/install/x86_64-osx/lts-5.5/7.10.3/bin
Registering haskell-stack-test-project-0.1.0.0...

The path to the built executable is contained in the line starting with Linking: Linking .stack-work/dist/x86_64-osx/Cabal-1.22.5.0/build/haskell-stack-test-project-exe/haskell-stack-test-project-exe ....

$ .stack-work/dist/x86_64-osx/Cabal-1.22.5.0/build/haskell-stack-test-project-exe/haskell-stack-test-project-exe
someFunc

Configure a Haskell project using IntelliJ IDEA

Install JetBrains' Haskell plug-in.
Configure Languages & Frameworks | Haskell:

If using binaries installed via cabal:

Create a Haskell project and its first component.

Use menu File | New | Project and select 'Haskell', click 'next', and choose name for the project and the name for the first module and its sub-directory:

Set GHC (ghc) as the platform SDK: use menu File | Project Structure, and select '+' and navigate to the installation path of the desired version of ghc, e.g. /Users/meng/.stack/programs/x86_64-osx/ghc-7.10.3 which is installed via stack or /usr/local/Cellar/ghc/7.10.3, which is installed via brew.

Optionally, create additional modules in the project: use menu File | New | Module, select 'Haskell', and choose name for the module and directory.

References

A 2-hour long video tutorial on setting up Haskell environment using stack by Christopher Allen and Julie Moronuki: https://www.youtube.com/watch?v=sRonIB8ZStw.
https://www.stackage.org/
The Haskell Tool Stack documentation, http://docs.haskellstack.org/en/stable/README/
- guide: http://docs.haskellstack.org/en/stable/GUIDE/

pages tagged haskell

Haskell

Journal

Entering multi-line code in GHCi

Using the latest released version of GHC with stack

data, type, and newtype

Nothing and Maybe

Partial application

Function type decalaration

Pure as in 'pure functional programming languages'

Get information about a Haskell word in GHCi

Concatenating multiple strings into one using intercalate, intersperse and concat, and unword.

Function application takes precedence over any binary operator.

guard

Changing a prefixing function to an infix binary operator

Largest integer

Arithmetic expression with different types of numbers

References

Haskell

Misc

Softwares

IDE's

Haskell and Wolfram Language syntax comparison

《Learn You a Haskell for Great Good!》 study note

Introduction

Starting out

Ready, set, go!

An intro to lists

Other side notes

References

Installing and configuring Haskell

cabal VS. stack

Install Haskell compiler and softwares using stack

Install Haskell compiler and softwares using cabal

Verifying the stack and Haskell installation

Configure Emacs for Haskell development

Configure a Haskell project using stack

Create a project

Build

Configure a Haskell project using IntelliJ IDEA

References

`data`, `type`, and `newtype`

`Nothing` and `Maybe`

Concatenating multiple strings into one using `intercalate`, `intersperse` and `concat`, and `unword`.

`cabal` VS. `stack`

Install Haskell compiler and softwares using `stack`

Install Haskell compiler and softwares using `cabal`

Configure a Haskell project using `stack`