Package

purescript-neon

Repository
tfausak/purescript-neon
License
MIT
Uploaded by
adius
Published on
2018-01-17

Package version Build status

Neon is a practical standard library for PureScript.

-- Find the sum of all the multiples of 3 or 5 below 1000.
-- <https://projecteuler.net/problem=1>
import Neon
main :: Eff (console :: CONSOLE) Unit
main = 1
  :upTo 999
  :filter (divisibleBy 3 || divisibleBy 5)
  :sum
  :print

Neon is written from the ground up to be useful and coherent. It has some guiding principles:

  • If something is possible in JavaScript (and not a terrible idea), it should be possible in Neon. This means you can do "ab" + "cd", but you can't do "ab" + 3.

  • Functions should take their subject last. This means add x y is really y + x. Consider calling functions with :, like y :add x.

  • Everything should be documented with examples. Type signatures are not a substitute for documentation.

  • Laws should not prohibit useful instances. This means you can use or on booleans and arrays.

  • There should be no type class hierarchy. This means HasZero does not imply HasAdd. If you need both, add both to your type signature.

  • There should be as few operators as possible. This means <$> does not exist. Use map instead.

  • There should be one obvious way to do things. This means return is not an alias for pure. In fact, it doesn't exist at all.

  • Functions should be defined in type classes. This means add can be used for both numbers and strings.

  • Type classes should be as small as possible. This means the Bounded type class is split into HasBottom and HasTop.

  • Type classes should be designed for programmers, not mathematicians. This means HasAdd is a semigroup, but it's not called Semigroup.

  • Neon should not define its own data types. That means you can use Maybe from Data.Maybe without translation.

  • Pure functions should not throw exceptions. This means fromInt returns a Maybe value. Pure functions that throw exceptions should be marked unsafe.

  • Qualified imports are annoying, and fewer imports are better. This mean import Neon is enough. No need for tens of lines of imports.

Modules
Neon
Neon.Class
Neon.Class.HasAdd
Neon.Class.HasAnd
Neon.Class.HasApply
Neon.Class.HasBottom
Neon.Class.HasChain
Neon.Class.HasCompare
Neon.Class.HasDivide
Neon.Class.HasEqual
Neon.Class.HasFilter
Neon.Class.HasFromArray
Neon.Class.HasFromInt
Neon.Class.HasGreater
Neon.Class.HasInspect
Neon.Class.HasLess
Neon.Class.HasMap
Neon.Class.HasMultiply
Neon.Class.HasNot
Neon.Class.HasOne
Neon.Class.HasOr
Neon.Class.HasPower
Neon.Class.HasPure
Neon.Class.HasReduce
Neon.Class.HasRemainder
Neon.Class.HasSubtract
Neon.Class.HasToArray
Neon.Class.HasToInt
Neon.Class.HasTop
Neon.Class.HasTraverse
Neon.Class.HasZero
Neon.Data
Neon.Effect
Neon.Helper
Neon.Operator
Neon.Primitive
Neon.Primitive.Char
Neon.Primitive.Function
Neon.Primitive.Int
Neon.Primitive.Number
Dependencies