#dc comics#dc#batman#batfam#bruce wayne#dick grayson#tim drake#batfamily#dc fanart
seen from Brazil
seen from Russia
seen from United Kingdom
seen from Ghana
seen from United States
seen from Russia
seen from Malaysia
seen from Armenia
seen from United States
seen from United States
seen from United States
seen from United States
seen from United Kingdom
seen from Estonia
seen from Malaysia
seen from South Africa
seen from United Kingdom
seen from United Kingdom
seen from South Africa
seen from Germany
Master JavaScript Object Functions - Ultimate Guide
Here’s what I wanted to do, for example (it doesn’t work obviously but I want to show y’all what I mean): let animations = { ‘jump’: function(){player.velocity.y += 15}, ‘fall’: function(){player.velocity.y -= 15} } let x = ‘jump’; animations.x(); Idk if this is the most convenient way to do things by the way, but I really like the cleanliness of syntax it’ll afford me. The original question,…
Anya is live and ready to show you everything. Watch her strip, dance, and perform exclusive shows just for you. Interact in real-time and make your fantasies come true.
Free to watch • No registration required • HD streaming
Lots of web animation that can be created using the HTML, CSS and JavaScript. Here are the list and code of 10 best Gravity Points example
10 Gravity Points Example
blog_examples - Example code featured on blog.greatlemer.com
If anyone wants a quick way to obtain any of the example code I’ve put up on this blog so far then here it is on github, ready to fork if necessary.
JSON Parsing in elm Part Three
The last post on this topic covered how to parse more complex objects, this time I provide an example where fields may be of varying types.
Through these examples you can see that the parsing isn't actually too difficult, you just have to break it down into smaller chunks where appropriate.
- G
Warning: if this looks all grouped together try viewing the original post page
module IntermediateJsonParsing where import Dict exposing (Dict) import Html exposing (Html) import Json.Decode exposing ((:=), Decoder, decodeString, float, int, list, map, object1, object2, oneOf, string) type UnknownKey = Stringy String | Integery Int type alias MixedObject = { type_ : String , key : UnknownKey } type alias MixedObjectList = List MixedObject type alias ListContainer = { aListOfObjects : MixedObjectList } -- An advanced map containing a list of mixed objects. advancedJson : String advancedJson = """{ "aListOfObjects" : [ { "type_" : "SomethingStringy", "stringKey" : "A String Value" }, { "type_" : "SomethingIntegery", "integerKey" : 12 } ] }""" -- Simple function to just return the list part of our object. extractList : ListContainer -> MixedObjectList extractList outerObject = outerObject.aListOfObjects -- We use oneOf to say that the value could match any of these -- possibilities. map then ensures that it's converted to the -- appropriate type. mixedObjectDecoder : Decoder MixedObject mixedObjectDecoder = object2 MixedObject ("type_" := string) (oneOf [ ("stringKey" := map Stringy string) , ("integerKey" := map Integery int) ] ) -- This part is actually fairly simple although we do use the -- map function to ensure that we're returning the inner -- object list ignoring the outer container. advancedDecoder : Decoder MixedObjectList advancedDecoder = map extractList ( object1 ListContainer ("aListOfObjects" := list mixedObjectDecoder) ) -- A simple function that tries to decode a JSON string with a -- decoder of our choice parseJson : String -> Decoder MixedObjectList -> String parseJson jsonString decoder = case decodeString decoder jsonString of Ok val -> toString val Err err -> err -- Display the result main : Html main = Html.div [] [ Html.text (parseJson advancedJson advancedDecoder) ]
Anya is live and ready to show you everything. Watch her strip, dance, and perform exclusive shows just for you. Interact in real-time and make your fantasies come true.
Free to watch • No registration required • HD streaming
JSON parsing in Elm part two
So in my previous post on this topic, I ran through how to extract data from a JSON string using Elm if you were just dealing with a simple structure where all the values were of the same type. This example looks at a slightly more complex structure where we're dealing with values of varying types.
- G
Warning: if this looks all grouped together try viewing the original post page
module IntermediateJsonParsing where import Dict exposing (Dict) import Html exposing (Html) import Json.Decode exposing ((:=), bool, Decoder, decodeString, float, int, list, object5, string) type alias IntermediateItem = { aFloat : Float , aString : String , anInteger : Int , aBoolean : Bool , aListOfIntegers : List Int } -- An intermediate map of strings to things intermediateJson : String intermediateJson = """{ "aFloat" : -1.010101, "aString" : "Some sort of text", "anInteger" : 12, "aBoolean" : true, "aListOfIntegers" : [1,2,3,2,1] }""" -- the objectX functions allow more complex objects (of up to 8 keys) -- to be extracted. The := function is a shortcut for defining the -- type of each key. intermediateDecoder : Decoder IntermediateItem intermediateDecoder = object5 IntermediateItem ("aFloat" := float) ("aString" := string) ("anInteger" := int) ("aBoolean" := bool) ("aListOfIntegers" := list int) -- A simple function that tries to decode a JSON string with a -- decoder of our choice parseJson : String -> Decoder IntermediateItem -> String parseJson jsonString decoder = case decodeString decoder jsonString of Ok val -> toString val Err err -> err -- Display the result main : Html main = Html.div [] [ Html.text (parseJson intermediateJson intermediateDecoder) ]
JSON parsing in Elm part one
Elm is an interesting language to use when writing front-end web code, however there are a few things that aren’t quite so obvious and JSON parsing is one of them. This example shows how you can parse JSON when the structure is very simple (a dict with all the values being of the same type).
- G
Warning: if this looks all grouped together try viewing the original post page
module BasicJsonParsing where import Dict exposing (Dict) import Html exposing (Html) import Json.Decode exposing (Decoder, decodeString, dict, float) -- A basic map of strings to floats basicJson : String basicJson = """{ "key1" : -1.0, "key2" : 1.4142, "key3" : -1.7321, "key4" : 2.0 }""" -- Here we use the 'dict' decoder telling it that we want it to -- extract floats basicDecoder : Decoder (Dict String Float) basicDecoder = dict float squareValue : String -> Float -> Int squareValue key value = round (value * value) -- A simple function that tries to decode a JSON string with a -- decoder of our choice parseJson : String -> Decoder (Dict String Float) -> String parseJson jsonString decoder = case decodeString decoder jsonString of Ok val -> toString (Dict.map squareValue val) Err err -> err -- Display the result main : Html main = Html.div [] [ Html.text (parseJson basicJson basicDecoder) ]
Simple mesh-like structure verified
Here is my stepping-stone up to verification of the actual project code. This structure stores two lists of "Paired" objects which each has a pointer and its invariants require that the pointers of items in one list point to items in the other list in corresponding pairs... a simple mesh-like structure.
The last thing I figured out here was the necessity of the \arrays_disjoint invariant and the invariant ensuring that the array object aliases aren't identical.
There remain a couple of assertions in the dispose function and I'm not sure why they are required.
Code:
//100% WORKING PAIRED LISTS IMPLEMENTATION #include <vcc.h> #include <stdlib.h> //malloc typedef struct Paired Paired; typedef struct Paired { Paired* pair; //_(invariant \approves(\this->\owner, pair)) //This isn't needed since no volatile updates happen to these //Any Paired owned by a PairedLists is wrapped except while the PairedLists is unwrapped //Wrapping the PairedLists forces all of its invariants about the Paired(s) to check } Paired; typedef _(dynamic_owns) struct PairedLists { //The maximum sizes of the following arrays size_t num1; size_t num2; //Heap arrays storing Paired objects Paired* pairarray1; Paired* pairarray2; _(ghost \object arrayob1) _(ghost \object arrayob2) _(invariant arrayob1 == (Paired[num1])pairarray1) _(invariant arrayob2 == (Paired[num2])pairarray2) _(invariant \malloc_root(arrayob1)) _(invariant \malloc_root(arrayob2)) _(invariant \mine(arrayob1) && \mine(arrayob2)) //Insist that the arrays do not overlap _(invariant pairarray1 != pairarray2) _(invariant \arrays_disjoint(pairarray1, num1, pairarray2, num2)) //Maps of witnesses for the pair indexes between the two arrays //This lets me avoid using existential quantification in the invariants for this object _(ghost \natural PairedArray1_witnesses[\natural];) _(ghost \natural PairedArray2_witnesses[\natural];) _(invariant \forall \natural i; i < num1 ==> PairedArray1_witnesses[i] < num2) _(invariant \forall \natural j; j < num2 ==> PairedArray2_witnesses[j] < num1) //Pairing invariants //Why can't I pull out the \mine parts of this into separate parts like below? _(invariant \forall \natural i; i < num1 ==> \mine(&pairarray1[i]) && \mine(&pairarray2[PairedArray1_witnesses[i]]) && pairarray2[PairedArray1_witnesses[i]].pair == &pairarray1[i]) _(invariant \forall \natural j; j < num2 ==> \mine(&pairarray2[j]) && \mine(&pairarray1[PairedArray2_witnesses[j]]) && pairarray1[PairedArray2_witnesses[j]].pair == &pairarray2[j]) //Why can't I separate the \mine parts from the pair matching invariants (above) like this (below)? //_(invariant \forall \natural i; i < num1 ==> \mine(&pairarray1[i])) //_(invariant \forall \natural j; j < num2 ==> \mine(&pairarray2[j])) //_(invariant \forall \natural i; i < num1 ==> \mine(&pairarray2[PairedArray1_witnesses[i]])) //_(invariant \forall \natural j; j < num2 ==> \mine(&pairarray1[PairedArray2_witnesses[j]])) //_(invariant \forall \natural i; i < num1 ==> pairarray2[PairedArray1_witnesses[i]].pair == &pairarray1[i]) //_(invariant \forall \natural j; j < num2 ==> pairarray1[PairedArray2_witnesses[j]].pair == &pairarray2[j]) //The original attempt at an invariant, without witness storage. Inadmissible and I'm not sure how to fix that. /*_(invariant \forall size_t i; i < num1 ==> \mine(&pairarray1[i]) && \exists size_t j; j < num2 && \mine(&pairarray2[j]) && &pairarray1[i] == pairarray2[j].pair)*/ } PairedLists; void PairedListInit(PairedLists* dis) _(writes \extent(dis)) _(ensures \wrapped(dis)) { _(ghost dis->\owns = {};) dis->num1 = 2; dis->num2 = 2; dis->pairarray1 = malloc(dis->num1*sizeof(Paired)); dis->pairarray2 = malloc(dis->num2*sizeof(Paired)); //Ignore malloc failure for the sake of testing the rest of this stuff concisely _(assume dis->pairarray1 != NULL) _(assume dis->pairarray2 != NULL) //Initialize the pairs and witnesses //If any of these following few lines are removed, the PairedLists's pairing invariant is not satisfied. Comment any of these to test that the invariant is working correctly. dis->pairarray1[0].pair = &dis->pairarray2[0]; _(ghost dis->PairedArray1_witnesses[0] = 0) dis->pairarray2[0].pair = &dis->pairarray1[0]; _(ghost dis->PairedArray2_witnesses[0] = 0) dis->pairarray1[1].pair = &dis->pairarray2[1]; _(ghost dis->PairedArray1_witnesses[1] = 1) dis->pairarray2[1].pair = &dis->pairarray1[1]; _(ghost dis->PairedArray2_witnesses[1] = 1) //Set \owns _(ghost dis->\owns += &dis->pairarray1[0];) _(ghost dis->\owns += &dis->pairarray1[1];) _(ghost dis->\owns += &dis->pairarray2[0];) _(ghost dis->\owns += &dis->pairarray2[1];) _(wrap &dis->pairarray1[0];) _(wrap &dis->pairarray1[1];) _(wrap &dis->pairarray2[0];) _(wrap &dis->pairarray2[1];) _(ghost dis->\owns += (Paired[dis->num1])dis->pairarray1) _(ghost dis->\owns += (Paired[dis->num2])dis->pairarray2) _(wrap (Paired[dis->num1])dis->pairarray1) _(wrap (Paired[dis->num2])dis->pairarray2) _(ghost dis->arrayob1 = (Paired[dis->num1])dis->pairarray1) _(ghost dis->arrayob2 = (Paired[dis->num2])dis->pairarray2) _(wrap dis) } void PairedListDispose(PairedLists* dis) _(requires \wrapped(dis)) _(writes dis) _(ensures \extent_mutable(dis)) { _(unwrap dis) _(assert \forall size_t i; i < dis->num1 ==> \wrapped(&dis->pairarray1[i])) _(assert \forall size_t j; j < dis->num2 ==> \wrapped(&dis->pairarray2[j])) _(unwrap dis->arrayob1) _(unwrap dis->arrayob2) for(size_t i = 0; i < dis->num1; i++) _(writes \array_members(dis->pairarray1,dis->num1)) _(invariant \forall size_t j; j >= i && j < dis->num1 ==> \wrapped(dis->pairarray1+j)) _(invariant \forall size_t j; j < i ==> \mutable(dis->pairarray1+j)) { _(unwrap &dis->pairarray1[i]) } for(size_t i = 0; i < dis->num2; i++) _(writes \array_members(dis->pairarray2,dis->num2)) _(invariant \forall size_t j; j >= i && j < dis->num2 ==> \wrapped(dis->pairarray2+j)) _(invariant \forall size_t j; j < i ==> \mutable(dis->pairarray2+j)) { _(unwrap &dis->pairarray2[i]) } free( _(Paired[dis->num1])dis->pairarray1); free( _(Paired[dis->num2])dis->pairarray2); } void FunctionTester() { PairedLists init_me; PairedListInit(&init_me); PairedListDispose(&init_me); }
