Skip to content
This repository has been archived by the owner on Dec 15, 2020. It is now read-only.

Scala sample code for Bartosz Milewski's CT for Programmers

Notifications You must be signed in to change notification settings

typelevel/CT_from_Programmers.scala

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

57 Commits
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Scala sample code for Bartosz Milewski's Category Theory for Programmers

Build Status Gitter

WIP

Contributing

Any contribution (PR, review, issues) will be more than welcome! If you are interested, please indicate that you are working on a certain section in the respective issue. You can find the issues here..

To compile

sbt tut

Style guide

Use ```tut:silent``` for code that is compilable, use ```scala``` otherwise.

Use a line of ............. to separate between code examples.

There are multiple ways to translate haskell code into scala. For scala syntax, generally speaking we follow the common styles in FP scala codebase (e.g. typelevel/cats)

functions vs. methods

If it's a "standalone" function, use the function syntax, i.e.

val f: A => B = ???

If it is inside a trait or class, use the method, i.e.

def f(a: A) : B = ???

Currying

Follow the common strategies in FP codebases, roughly

  • if there is one function parameter, create a dedicated parameter list for it and make it the last parameter list.
  • if there are multiple function parameters, group them together, and put them in a dedicated last parameter list.
  • of course, implicit parameters have to go in a separate parameter list
  • everything else should go to a single parameter list.
  • if the haskell code partially applied the function, partially apply with underscore in scala code.

Infix syntax for type class methods

Create a XXXOps implicit extension class to support such infix syntax. E.g. To support (m1: A => Writer[B]) >=> (m2: B => Writer[C]) add

  implicit class Kleisli[A, B](m1: A => Writer[B]) {
   def >=>[C](m2: B => Writer[C]): A => Writer[C] = ...

Indentation and line break

Use 2 space indentation and prefer to aggressively break lines

def >=>[C](m2: B => Writer[C]): A => Writer[C] 
   = { x => 
     ...
   }

If the signature is too long, we break it to multiple lines as well. Control each line to be within 45 characters.

Symbol names

For the prime symbol, use U+16CC RUNIC LETTER SHORT-TWIG-SOL S , it works with scalac while the unicode prime symbol doesn't

License

CC image

This work is licensed under a Creative Commons Attribution 4.0 International License.

About

Scala sample code for Bartosz Milewski's CT for Programmers

Resources

Code of conduct

Security policy

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published

Languages