1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
|
import React from "react";
import { FeatureItem } from "./feature-item";
export const ReadyFeatures: FeatureItem[] = [
{
title: "A Static that feels like Dynamic",
description: (
<>
NeoHaskell's type system is so powerful that you'll forget it's there.
With type inference, you'll spend less time annotating and more time
coding in a language that feels dynamic.
</>
),
buttonText: "Start Coding",
showcase: {
language: "haskell",
code: `verify = do
joe <- getPerson "Joe"
if joe.age > 18 then
print "Joe is an adult"
else
print "Joe is a child"`,
},
},
{
title: "Lazy Evaluation for Eager Minds",
description: (
<>
NeoHaskell won't evaluate an expression until it's absolutely needed.
This lets you create more efficient code and focus on what to compute
rather than how to compute it.
</>
),
buttonText: "Get Lazy, Be Efficient",
showcase: {
language: "haskell",
code: `let infiniteList = [1..]
let doubledList = List.map (*2) infiniteList
print (List.toString doubledLis)`,
},
},
{
title: "Fearless Concurrency",
description: (
<>
<p>
Concurrency is not an afterthought in NeoHaskell; it's baked right in.
Write concurrent code without the common pitfalls, and get more done,
faster.
</p>
<br />
<p>
Functions like <code>async</code> and <code>race</code> make it easy
to write concurrent code. And with concepts like Channels, you'll be
able to write concurrent code without the headaches.
</p>
</>
),
buttonText: "Unlock Concurrency",
showcase: {
language: "haskell",
code: `foo = do
threadDelay 500
print "foo"
bar = do
threadDelay 1000
print "bar"
-- will print "foo" and exit
main = race foo bar`,
},
},
{
title: "Event Sourcing and CQRS Ready",
description: (
<>
NeoHaskell aligns well with modern architectural patterns like Event
Sourcing and CQRS, making it easier for you to build scalable and
maintainable systems.
</>
),
buttonText: "Build Modern Systems",
showcase: {
language: "haskell",
code: `reduction = do
myEvents <- getEvents "myAggregate"
return (
Stream.reduce
myReducer
initialState
myEvents
)`,
},
},
];
|
