Comments (21)
Exercise: hello-world
Code
module HelloWorld where
import Prelude
import Data.Maybe (Maybe(..))
helloWorld :: Maybe String -> String
helloWorld Nothing = "Hello, World!"
helloWorld (Just name) = "Hello, " <> name <> "!"
Tags:
construct:string
construct:<>
construct:import
construct:module
construct:pattern-matching
construct:function
construct:parameter
construct:string
construct:variable
paradigm:functional
paradigm:metaprogramming
technique:concatenation
from purescript.
Exercise: bob
Code
module Bob
( hey
) where
import Prelude
import Data.Either (fromRight)
import Data.List (findMap)
import Data.Maybe (isJust, fromMaybe, Maybe(..))
import Data.String (Pattern(..), length, stripSuffix, trim)
import Data.String.Regex (Regex, regex, test)
import Data.String.Regex.Flags (RegexFlags, noFlags)
import Partial.Unsafe (unsafePartial)
hey :: String -> String
hey s =
fromMaybe "Whatever." $ findMap (\x -> x s) [isYelling, isQuestion, isSilent]
isQuestion :: String -> Maybe String
isQuestion s
| s # stripSuffix (Pattern "?") # isJust = Just "Sure."
| otherwise = Nothing
isSilent :: String -> Maybe String
isSilent s
| s # trim # length # (==) 0 = Just "Fine. Be that way!"
| otherwise = Nothing
isYelling :: String -> Maybe String
isYelling s
| test (getRegex "^(?=.*[A-Z]+)[^a-z]+[!?]?$" noFlags) s = Just "Whoa, chill out!"
| otherwise = Nothing
getRegex :: String -> RegexFlags -> Regex
getRegex pattern flags =
unsafePartial $ fromRight $ regex pattern flags
Tags:
No tags generated
from purescript.
Exercise: pangram
Code
module Pangram (isPangram) where
import Prelude (map, ($))
import Data.String (toLower, toCharArray)
import Data.Char (fromCharCode)
import Data.Array ((..))
import Data.Set (difference, fromFoldable, isEmpty)
isPangram :: String -> Boolean
isPangram str =
let
alpha = fromFoldable $ map fromCharCode $ 97..122
letters = fromFoldable $ toCharArray $ toLower str
in
isEmpty $ difference alpha letters
Tags:
construct:boolean
construct:char
construct:double
construct:expression
construct:implicit-conversion
construct:import
construct:infix-function
construct:int
construct:integral-number
construct:invocation
construct:let
construct:number
construct:parameter
construct:set
construct:string
construct:underscore
construct:variable
construct:visibility-modifiers
paradigm:functional
paradigm:object-oriented
paradigm:reflective
technique:higher-order-functions
uses:Set
from purescript.
Exercise: scrabble-score
Code
module ScrabbleScore (scoreWord) where
import Prelude ((#), (+), (/=), ($))
import Data.Array (foldl)
import Data.Maybe (Maybe(Nothing))
import Data.Tuple (Tuple(..), fst, snd)
import Data.String (Pattern(..), indexOf, singleton, toCharArray, toLower)
scoreWord :: String -> Int
scoreWord word =
let
wordChars = toLower word # toCharArray
in
foldl (\acc x -> acc + charToScore x) 0 wordChars
charToScore :: Char -> Int
charToScore char =
let
charsWithScore = [
Tuple "aeioulnrst" 1,
Tuple "dg" 2,
Tuple "bcmp" 3,
Tuple "fhvwy" 4,
Tuple "k" 5,
Tuple "jx" 8,
Tuple "qz" 10
]
in
foldl (\acc x ->
acc + if indexOf (Pattern $ singleton char) (fst x) /= Nothing
then snd x else 0
) 0 charsWithScore
Tags:
construct:array
construct:char
construct:constructor-application
construct:function
construct:if-then-else
construct:implicit-conversion
construct:import
construct:int
construct:integral-number
construct:invocation
construct:lambda
construct:let
construct:list
construct:number
construct:parameter
construct:pattern-matching
construct:string
construct:tuple
construct:variable
paradigm:functional
technique:higher-order-functions
uses:Char
uses:List
uses:Tuple
from purescript.
Exercise: scrabble-score
Code
module ScrabbleScore (scoreWord) where
import Prelude ((==), (>>>), (+), otherwise)
import Data.Foldable (foldr)
import Data.String (Pattern(..), split, toLower)
import Data.Record.Unsafe (unsafeGet, unsafeHas)
scoreMap = { a: 1
, b: 3
, c: 3
, d: 2
, e: 1
, f: 4
, g: 2
, h: 4
, i: 1
, j: 8
, k: 5
, l: 1
, m: 3
, n: 1
, o: 1
, p: 3
, q: 10
, r: 1
, s: 1
, t: 1
, u: 1
, v: 4
, w: 4
, x: 8
, y: 4
, z: 10
}
letterToScore :: String -> Int
letterToScore l
| (unsafeHas l scoreMap) == true = unsafeGet l scoreMap
| otherwise = 0
scoreWord :: String -> Int
scoreWord = (split (Pattern "")) >>> foldr (toLower >>> letterToScore >>> (+)) 0
Tags:
construct:boolean
construct:add
construct:assignment
construct:char
construct:comment
construct:field-initializer
construct:function
construct:import
construct:int
construct:integral-number
construct:invocation
construct:lambda
construct:method
construct:module
construct:number
construct:object
construct:parameter
construct:pattern-matching
construct:record
construct:string
construct:underscore
construct:variable
construct:visibility-modifiers
paradigm:functional
paradigm:imperative
paradigm:object-oriented
technique:higher-order-functions
uses:Pattern
from purescript.
Exercise: triangle
Code
module Triangle
( Triangle(Equilateral, Isosceles, Scalene)
, triangleKind
) where
import Data.Either (Either(..))
import Data.Array (any)
import Data.Tuple (Tuple(..), uncurry)
import Data.Generic (gShow, class Generic)
import Prelude
data Triangle = Equilateral | Isosceles | Scalene
derive instance eqT ∷ Eq Triangle
derive instance genericT ∷ Generic Triangle
instance showT ∷ Show Triangle where
show = gShow
-- I don't like the usage of String as errors, so if it was me I would
-- define triangleKind to go to Either InvalidTriangleReason Triangle
-- Since that's not the case, how about another show instance? :)
data InvalidTriangleReason = NonPositiveLengths | InequalityViolated
instance showITR ∷ Show InvalidTriangleReason where
show itr = case itr of
NonPositiveLengths → "Invalid lengths"
InequalityViolated → "Violates inequality"
triangleKind ∷ Int → Int → Int → Either String Triangle
triangleKind a b c
| any (_ <= 0) [a, b, c] = Left $ show NonPositiveLengths
| any (uncurry (\x y → x < y)) [Tuple (b+c) a, Tuple (a+c) b, Tuple (a+b) c] = Left $ show InequalityViolated
| a == b && b == c = Right Equilateral
| a == b || b == c || a == c = Right Isosceles
| otherwise = Right Scalene
Tags:
construct:add
construct:boolean
construct:case
construct:class
construct:comment
construct:data-declaration
construct:import
construct:instance
construct:int
construct:integral-number
construct:lambda
construct:list
construct:logical-and
construct:logical-or
construct:module
construct:number
construct:pattern-matching
construct:polymorphic-function
construct:string
construct:sum-type
construct:tuple
construct:underscore
construct:variable
paradigm:functional
paradigm:object-oriented
technique:boolean-logic
technique:higher-order-functions
uses:List
uses:Tuple
from purescript.
Exercise: triangle
Code
module Triangle
( Triangle (Equilateral, Isosceles, Scalene)
, triangleKind
) where
import Prelude
import Data.Array (sort)
import Data.Either (Either(..))
import Data.Generic.Rep (class Generic)
import Data.Generic.Rep.Show (genericShow)
import Partial.Unsafe (unsafeCrashWith)
data Triangle = Equilateral | Isosceles | Scalene
derive instance eqTriangle :: Eq Triangle
derive instance genericTriangle :: Generic Triangle _
instance showTriangle :: Show Triangle where show = genericShow
triangleKind' :: Int → Int → Int → Either String Triangle
triangleKind' a b c
| a < 1 = Left "Invalid lengths"
| a + b <= c = Left "Violates inequality"
| a == b && b == c = Right Equilateral
| a == b || b == c = Right Isosceles
| otherwise = Right Scalene
triangleKind :: Int → Int → Int → Either String Triangle
triangleKind a b c =
case sort [a, b, c] of
[a', b', c'] -> triangleKind' a' b' c'
_ -> unsafeCrashWith "impossible"
Tags:
construct:add
construct:boolean
construct:case
construct:data-declaration
construct:import
construct:instance
construct:invisibility-modifier
construct:lambda
construct:list
construct:logical-and
construct:logical-or
construct:module
construct:parameter
construct:pattern-matching
construct:string
construct:underscore
construct:use
construct:visibility-modifiers
paradigm:functional
paradigm:logical
paradigm:object-oriented
technique:boolean-logic
from purescript.
Exercise: matching-brackets
Code
module BracketPush (isPaired) where
import Prelude ((#), (==))
import Data.Map as M
import Data.Tuple (Tuple(..))
import Data.String (toCharArray)
import Data.Array (foldl, snoc, elemIndex, last, null, init)
import Data.Maybe (Maybe(Just), isJust, maybe, fromMaybe)
bracketsMap :: M.Map Char Char
bracketsMap = M.fromFoldable [
Tuple '(' ')',
Tuple '{' '}',
Tuple '[' ']'
]
closingBrackets :: Array Char
closingBrackets = [')', '}', ']']
isPaired :: String -> Boolean
isPaired str =
toCharArray str #
foldl checkBrackets [] #
null
checkBrackets :: Array Char -> Char -> Array Char
checkBrackets stack char =
if M.member char bracketsMap then
snoc stack char
else if isJust (elemIndex char closingBrackets) then
let lastBracket = last stack in
maybe stack (
\bracket ->
if Just char == M.lookup bracket bracketsMap then
fromMaybe [] (init stack)
else
snoc stack char
) lastBracket
else
stack
Tags:
construct:array
construct:char
construct:if-then-else
construct:implicit-conversion
construct:import
construct:invocation
construct:lambda
construct:let
construct:list
construct:method
construct:module
construct:null
construct:nullary
construct:parameter
construct:string
construct:then-expression
construct:tuple
construct:variable
construct:visibility-modifiers
paradigm:functional
paradigm:object-oriented
technique:higher-order-functions
uses:Map
from purescript.
Exercise: allergies
Code
module Allergies
( allergicTo
, list
) where
import Prelude
import Data.Array (filter, zip)
import Data.Int.Bits ((.&.))
import Data.Map (Map)
import Data.Map as Map
import Data.Maybe (Maybe(..))
allergens :: Array String
allergens = ["eggs", "peanuts", "shellfish", "strawberries", "tomatoes", "chocolate", "pollen", "cats"]
powersOf2 :: Array Int
powersOf2 = [1, 2, 4, 8, 16, 32, 64, 128]
allergensMap :: Map String Int
allergensMap = Map.fromFoldable (zip allergens powersOf2)
allergicTo :: Int -> String -> Boolean
allergicTo n al = case Map.lookup al allergensMap of
Just i -> n .&. i /= 0
Nothing -> false
list :: Int -> Array String
list n = filter (allergicTo n) allergens
Tags:
construct:boolean
construct:case
construct:char
construct:double
construct:explicit-conversion
construct:expression
construct:field
construct:floating-point-number
construct:import
construct:infinite-precision-number
construct:int
construct:integral-number
construct:invocation
construct:lambda
construct:list
construct:module
construct:number
construct:parameter
construct:pattern-matching
construct:record
construct:string
construct:variable
construct:visibility-modifiers
paradigm:functional
paradigm:object-oriented
technique:bit-manipulation
technique:boolean
technique:higher-order-functions
technique:type-conversion
uses:Map
from purescript.
Exercise: all-your-base
Code
module AllYourBase
( rebase
) where
import Data.Foldable (class Foldable)
import Data.List.Lazy (foldMap, foldl)
import Data.Maybe (Maybe(..))
import Data.Monoid.Conj (Conj(..))
import Data.Tuple (Tuple(..))
import Data.Unfoldable (class Unfoldable, unfoldr)
import Data.Array (null, head, all, reverse)
import Prelude (mod, not, otherwise, (#), ($), (&&), (*), (+), (/), (<), (<=), (==), (>=))
rebase :: Int -> Int -> Array Int -> Maybe (Array Int)
rebase srcRadix destRadix digits
| srcRadix <= 1 = Nothing
| destRadix <= 1 = Nothing
| not $ all (isValidDigit srcRadix) digits = Nothing
| null digits = Nothing
| head digits == Just 0 = Nothing
| otherwise = Just $
fromFoldable digits # toUnfoldable # reverse
where
fromFoldable :: forall f. Foldable f => f Int -> Int
fromFoldable = foldl (\number digit -> number * srcRadix + digit) 0
toUnfoldable :: forall f. Unfoldable f => Int -> f Int
toUnfoldable = unfoldr (\number -> if number <= 0
then Nothing
else Just $ Tuple (number `mod` destRadix) (number / destRadix))
isValidRadix :: Int -> Boolean
isValidRadix radix = radix >= 2
isValidDigit :: Int -> Int -> Boolean
isValidDigit radix digit = 0 <= digit && digit < radix
Tags:
construct:add
construct:boolean
construct:class
construct:data-declaration
construct:divide
construct:export
construct:guarded-expression
construct:if-then-else
construct:import
construct:infix-operator
construct:int
construct:integral-number
construct:lambda
construct:logical-and
construct:method
construct:module
construct:multiply
construct:null
construct:number
construct:parameter
construct:pattern-matching
construct:record
construct:string
construct:underscore-identifier
construct:variable
construct:visibility-modifiers
paradigm:functional
paradigm:object-oriented
technique:boolean-logic
technique:higher-order-functions
from purescript.
Exercise: difference-of-squares
Code
module DifferenceOfSquares (differenceOfSquares, squareOfSum, sumOfSquares) where
import Prelude
import Data.Array (range)
import Data.Foldable (sum)
squareOfSum :: Int -> Int
squareOfSum n =
sum * sum where sum = n * (n + 1) / 2
sumOfSquares :: Int -> Int
sumOfSquares 0 = 0
sumOfSquares n =
range 1 n #
map (\x -> x * x) #
sum
differenceOfSquares :: Int -> Int
differenceOfSquares n = squareOfSum n - sumOfSquares n
Tags:
construct:add
construct:assignment
construct:backslash
construct:divide
construct:export
construct:import
construct:int
construct:integral-number
construct:lambda
construct:local-binding
construct:module
construct:number
construct:operator-overloading
construct:subtract
construct:variable-shadowing
paradigm:functional
paradigm:imperative
paradigm:object-oriented
technique:higher-order-functions
from purescript.
Exercise: diamond
Code
module Diamond
(rows
) where
import Prelude
import Data.Array (reverse, drop, (..))
import Data.Char (toCharCode)
import Data.Enum (enumFromTo)
import Data.String (fromCharArray)
rows ∷ Char → Array String
rows c =
map (row size) $ forward <> backward
where
size ∷ Int -- size of the diamond, depending on the char
size = 2*((toCharCode c) - 65)+1
forward ∷ Array Char
forward = enumFromTo 'A' c
backward ∷ Array Char
backward = drop 1 $ reverse forward
row ∷ Int → Char → String
row s x =
fromCharArray $ map (\i →
if i == middle-charNum || i == middle+charNum then
x
else
' ') $ 0..(s-1)
where
charNum = (toCharCode x) - 65
middle = s/2
Tags:
construct:add
construct:array
construct:char
construct:comment
construct:divide
construct:equivalence
construct:explicit-conversion
construct:function
construct:if-else
construct:import
construct:infix-function
construct:int
construct:integral-number
construct:lambda
construct:logical-or
construct:map
construct:module
construct:multiply
construct:number
construct:parameter
construct:string
construct:subtract
construct:variable
construct:visibility
paradigm:functional
paradigm:imperative
paradigm:object-oriented
technique:boolean-logic
technique:higher-order-functions
technique:type-conversion
from purescript.
Exercise: etl
Code
module Etl (transform) where
import Data.Array (concatMap)
import Data.Map (Map, fromFoldable, toUnfoldable)
import Data.Tuple (Tuple (..))
import Data.Char.Unicode (toLower)
import Prelude (map, (<<<))
type Old = Map Int (Array Char)
type New = Map Char Int
transform :: Old -> New
transform = fromFoldable <<< concatMap transformation <<< toUnfoldable
where transformation (Tuple val chars) = map (\x -> Tuple (toLower x) val) chars
Tags:
construct:array
construct:char
construct:deductive-reasoning
construct:expression
construct:export
construct:import
construct:invocation
construct:lambda
construct:map
construct:module
construct:name-shadowing
construct:pattern-matching
construct:qualified-name
construct:type
construct:type-alias
construct:where-clause
paradigm:functional
paradigm:logical
paradigm:object-oriented
technique:higher-order-functions
uses:Map
from purescript.
Exercise: etl
Code
module Etl
( transform
) where
import Prelude
import Data.Array
( concatMap
)
import Data.Char.Unicode
( toLower
)
import Data.Map
( Map
, fromFoldable
, toUnfoldable
)
import Data.Tuple
( Tuple (..)
, swap
)
transform :: Map Int (Array Char) -> Map Char Int
transform =
fromFoldable <<<
concatMap r <<<
toUnfoldable
where
r :: Tuple Int (Array Char) -> Array (Tuple Char Int)
r (Tuple v cs) = (swap <<< Tuple v <<< toLower) <$> cs
Tags:
construct:char
construct:double-less-than
construct:expression
construct:import
construct:invocation
construct:lambda
construct:module
construct:parameter
construct:pattern-matching
construct:qualified-name
construct:where-clause
construct:word
paradigm:functional
paradigm:higher-order-functions
from purescript.
Exercise: largest-series-product
Code
module LargestSeriesProduct (largestProduct) where
import Prelude
import Data.Array (range, slice)
import Data.Int (fromString)
import Data.Maybe (Maybe(..))
import Data.String (Pattern(..), split)
import Data.String.CodeUnits (length)
import Data.Traversable (maximum, product, traverse)
largestProduct ∷ String → Int → Maybe Int
largestProduct s n
| 0 > n || n > length s = Nothing
| otherwise = do
digits ← traverse fromString $ split (Pattern "") s
let go i = product $ slice i (i + n) digits
maximum $ go <$> (range 0 $ (_ - n) $ length s)
Tags:
construct:add
construct:boolean
construct:char
construct:do
construct:import
construct:infix-function
construct:int
construct:integral-number
construct:lambda
construct:let
construct:logical-or
construct:module
construct:number
construct:pattern-matching
construct:string
construct:subtract
construct:unicode-char
construct:variable
construct:visibility-modifiers
paradigm:functional
paradigm:imperative
paradigm:object-oriented
technique:boolean-logic
technique:higher-order-functions
from purescript.
Exercise: pascals-triangle
Code
module PascalsTriangle (rows) where
import Prelude
import Data.Array (drop, zipWith)
import Data.Maybe (Maybe(Just, Nothing))
rows :: Maybe Int -> Maybe (Array (Array Int))
rows Nothing = Nothing
rows (Just n)
| n < 0 = Nothing
| n == 0 = Just []
| otherwise = Just $ rows' [1] n
rows' :: Array Int -> Int -> Array (Array Int)
rows' row 1 = [row]
rows' row n =
let
nextRow current = zipWith (+) current (drop 1 current)
in
[row] <> rows' (nextRow $ [0] <> row <> [0]) (n - 1)
Tags:
construct:array
construct:binding
construct:char
construct:constructor
construct:function
construct:guarded-expression
construct:import
construct:infix-function
construct:int
construct:integral-number
construct:lambda
construct:let
construct:list
construct:minus
construct:module
construct:number
construct:parameter
construct:pattern-matching
construct:subtract
construct:underscore
construct:variable
construct:visibility-modifiers
paradigm:functional
paradigm:imperative
paradigm:object-oriented
technique:higher-order-functions
uses:Data.Array
uses:Data.List
uses:Data.Monoid.Monoid
uses:Data.Monoid.mempty
uses:Data.Monoid.(<>)
uses:Data.Tuple
uses:Data.Tuple.curry
uses:Data.Tuple.uncurry
from purescript.
Exercise: collatz-conjecture
Code
module CollatzConjecture
( collatz
) where
import Prelude
import Data.Int (even)
import Data.Maybe (Maybe(..))
collatz :: Int -> Maybe Int
collatz n = if n <= 0 then Nothing else Just (go n 0) where
go i acc | i == 1 = acc
| even i = go (i / 2) (acc + 1)
| otherwise = go (3*i + 1) (acc + 1)
Tags:
construct:add
construct:boolean
construct:divide
construct:if-then-else
construct:import
construct:int
construct:integral-number
construct:invocation
construct:lambda
construct:pattern-matching
construct:recursion
construct:subtract
construct:where-clause
paradigm:functional
paradigm:object-oriented
technique:higher-order-functions
from purescript.
Exercise: sum-of-multiples
Code
module SumOfMultiples
( sumOfMultiples
) where
import Prelude
import Control.MonadZero (guard)
import Data.Array (any, (..))
import Data.Foldable (class Foldable, sum)
sumOfMultiples ∷ ∀ t. Foldable t ⇒ t Int → Int → Int
sumOfMultiples xs cap = sum do
i ← 1 .. (cap-1)
guard $ any (\x → i `mod` x == 0) xs
pure i
Tags:
construct:application
construct:backtick
construct:class
construct:do
construct:forall
construct:function
construct:import
construct:int
construct:integral-number
construct:invocation
construct:lambda
construct:method
construct:module
construct:number
construct:operator
construct:subtract
construct:unicode
construct:variable
construct:visibility-modifiers
paradigm:functional
paradigm:object-oriented
technique:higher-order-functions
from purescript.
Exercise: sum-of-multiples
Code
module SumOfMultiples
( sumOfMultiples
) where
import Prelude
import Data.Foldable (sum)
import Data.List.Lazy (iterate, takeWhile)
import Data.Set (Set)
import Data.Set as Set
sumOfMultiples :: Array Int -> Int -> Int
sumOfMultiples multiples limit = map setOfMultiples multiples # Set.unions # sum
where
setOfMultiples :: Int -> Set Int
setOfMultiples start = Set.fromFoldable $ takeWhile (_ < limit) $ iterate (_ + start) start
Tags:
construct:array
construct:backtick-quoted-string
construct:hash
construct:import
construct:invocation
construct:lambda
construct:module
construct:parameter
construct:pattern-matching
construct:set
construct:underscore
construct:where-clause
construct:visibility-modifiers
paradigm:functional
paradigm:object-oriented
technique:higher-order-functions
uses:Set
from purescript.
Exercise: rna-transcription
Code
module RNATranscription
( toRNA
) where
import Data.Traversable (traverse)
import Data.Maybe (Maybe(..))
import Data.String (Pattern(..), split, joinWith)
import Prelude ((#), (<#>))
toRNA :: String -> Maybe String
toRNA dna = split (Pattern "") dna # traverse toRNA1 <#> joinWith ""
toRNA1 :: String -> Maybe String
toRNA1 "G" = Just "C"
toRNA1 "C" = Just "G"
toRNA1 "T" = Just "A"
toRNA1 "A" = Just "U"
toRNA1 _ = Nothing
Tags:
construct:#
construct:import
construct:module
construct:pattern-matching
construct:underscore
construct:function
construct:invocation
construct:lambda
construct:parameter
construct:string
construct:top-level-definition
construct:where-clause
paradigm:functional
technique:higher-order-functions
from purescript.
This is an automated comment
Hello 👋 Next week we're going to start using the tagging work people are doing on these. If you've already completed the work, thank you! If you've not, but intend to this week, that's great! If you're not going to get round to doing it, and you've not yet posted a comment letting us know, could you please do so, so that we can find other people to do it. Thanks!
from purescript.
Related Issues (20)
- Launch Tracker 🔴
- Add blurb to Concept Exercises
- Pulp Test failes to build RowList HOT 3
- Exercise dependencies HOT 5
- Inconsistent use of unit testing library HOT 3
- Update documentation after introducing spago
- Remove bower leftovers (post spago migration)
- 🤖 Sync error for commit 3b930c
- Rename `booleans` Concept Exercise to use story/theme
- Extract track-specific help instructions from `config/exercise_readme.go.tmpl`
- Extract track-specific test instructions from `config/exercise_readme.go.tmpl`
- [v3] Update doc links
- Build analyzer
- Check docs are up to date
- spago upgrade-set from 0.13.8 to 0.14.4 HOT 4
- Instructions doesn't match the test HOT 3
- Add signatures to all stub files HOT 2
- Including extra dependencies HOT 3
- CI is failing on main since Nov/Dec 2022 HOT 3
Recommend Projects
-
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
-
Vue.js
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
-
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
-
TensorFlow
An Open Source Machine Learning Framework for Everyone
-
Django
The Web framework for perfectionists with deadlines.
-
Laravel
A PHP framework for web artisans
-
D3
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
-
Recommend Topics
-
javascript
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
-
web
Some thing interesting about web. New door for the world.
-
server
A server is a program made to process requests and deliver data to clients.
-
Machine learning
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
-
Visualization
Some thing interesting about visualization, use data art
-
Game
Some thing interesting about game, make everyone happy.
Recommend Org
-
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
-
Microsoft
Open source projects and samples from Microsoft.
-
Google
Google ❤️ Open Source for everyone.
-
Alibaba
Alibaba Open Source for everyone
-
D3
Data-Driven Documents codes.
-
Tencent
China tencent open source team.
from purescript.