elm - Extract data from a signal -

i have signal this: signal1 = signal.constant {a=4, b=3, l = []}
how extract data signal?
have tried signal.map (\x -> x) signal1 signal.map returns signal.

if while programming in elm ever have questions like:

• “how extract value signal?”
• “how change variable value?”
• “where put foldp , arguments should pass it?”

you should read the elm architecture tutorial , try implement code along way. seriously, novice elm programmer should diligently go through tutorial start finish, clear of confusion.

nevertheless, i'll give simplified summary — bear in mind omit lots of details , complexities. if you've read tutorial, understand, how typical elm program structured. there 3 main parts in elm programs: model, update, , view.

model contains initial values program data, , type definitions. update takes event , model, , returns modified model based on event. view takes model (at whatever stage program is) , draws on screen, in other words, returns element.

in simple program, can render whatever signals emit, without storing intermediate state, applying signal.map rendering function , signal. below, function show plays role of primitive view. don't use models or updates, because render whenever mouse signal emits new event.

import graphics.element exposing (element, show) import mouse import signal exposing (signal, map)  main : signal element main = map show mouse.isdown 

but if want maintain state between events, have use foldp, either directly or through higher-level abstraction. state mean model, modified successive applications of update function. @ point in time model in state. main this:

main = map view (foldp update model signal) 

main function has type signal element — there exceptions, behind scenes converted signal element anyway. whatever data, code, , functions, @ point have combine of type signal element, body of main function.

a model record many fields, of can records too. update has type event -> model -> model, model type of model , event whatever final signal emits. view has type model -> element. (the type names don't have event , model, use them placeholders in example).

you can't extract values signal, deliberately impossible in elm. instead lift function signal context, using signal.map. manipulation values emitted signal done within signal context functions lifted it. suppose have signal of type signal event. foldp update model signal have type signal model, because foldp has type:

foldp : (a -> state -> state) -> state -> signal -> signal state 

if view function has type model -> element, map view (foldp update model signal) have type signal element.

main mandated have type signal element, therefore map view (foldp update model signal) can body of main.

import graphics.element exposing (element, show) import mouse import signal exposing (signal, foldp, map)  type alias model = int model : model model = 0  update : () -> model -> model update event model = model + 1  view : model -> element view model = show model  main : signal element main = map view (foldp update model mouse.clicks) 

above simple program accumulates mouse clicks. have dummy event, , our model integer. how signal.map function work? has type:

map : (a -> b) -> signal -> signal b 

it takes ordinary function converts value value, , takes signal of first value, produce signal of second value. suppose have lots of various signals, emit values corresponding mouse clicks, key presses, timed events, html input fields, kinds of stuff. manipulate these signals way like, @ point merge them 1 final signal, type signal something (where corresponds complicated datatype, containing input data need program).

because must have main function, @ point have convert final signal signal element, @ point have map (lift) function of type something -> element on signal something signal element. why called lifting? because of partial application these 2 type definitions of signal.map equivalent:

map : (a -> b) -> signal -> signal b map : (a -> b) -> (signal -> signal b) 

you lift ordinary day-to-day function of type a -> b signal context, can work on signals of values instead of values. here more complicated example counts both seconds , mouse clicks:

import graphics.element exposing (element, show) import mouse import signal exposing (signal, foldp, map, merge) import time exposing (time, fps, inseconds)  type alias model = { clicks : int, time : int } model : model model = { clicks=0, time=0 }  type event = seconds int | mouse () update : event -> model -> model update event model = case event of   seconds time -> { model | time <- model.time + time }   mouse () -> { model | clicks <- model.clicks + 1 }  view : model -> element view model = show model  timesignal = seconds << round << inseconds <~ fps 1 mousesignal = map mouse mouse.clicks  signal : signal event signal = merge timesignal mousesignal  main : signal element main = map view (foldp update model signal) 

now, hope, have basic understanding how elm programs structured , how handle events emitted signals , modify data event event. can extend above program adding more signals, making model more complex, , making view draw fancier output.