 {data: apiData}: {data:CreateBlahMutation} = await API.graphql(graphqlOperation(mutations.createShop, {input}));

This will assign the data property of await API.graphql(...) to the variable apiData.

 Q:

Why does Color use Int32 over Byte?

Using this example:
Color.FromArgb(Int32, Int32, Int32)

Creates a Color structure from the specified 8-bit color values (red,
green, and blue). The alpha value is implicitly 255 (fully opaque).
Although this method allows a 32-bit value to be passed for each color
component, the value of each component is limited to 8 bits.

If the value of each component is limited to 8 bits, then why didn't they use Byte instead of Int32?
In broader scope, I find people using Int32 very commonly, even when Int16 or Byte would suffice. Is there any particular reason for using Int32 generally over Int16, Byte, etc?

A:

My guess is that byte is less well supported by some.NET languages. Maybe it's not CLS compliant, I don't remember. These days nobody cares about CLS compliance anymore but in the 1.0 days this was an important feature level. Also note that VB.NET does not support unsigned types well which is an example of different support for integers across.NET languages.
Using int for the constructor is especially weird because the A, R, G, B properties are byte.
I consider this to be an API design error.
The Color struct is not particularly beautiful in general. It does not only have ARGB values but also a KnownColor and a name. Many concerns have been crammed into this struct. For fun, the Equals method has a bug: return name.Equals(name);. This is always true, of course. This struct looks hastily done. You can tell from the Equals method that the code author did not know that strings have an overloaded equality operator. The operator equals of Color is the same 15 lines just copied over. I guess the true answer for this question is: The intern did it!

Generally, Int32 is preferred because most arithmetic operations widen to 32 bits and it's an efficient integer width for common hardware. The shorter integer types are for more special uses.
Since it was suggested that this saves down
{ data: apiData }: { data: CreateBlahMutation } = await API.graphql(graphqlOperation(mutations.createShop, { input }) ); 

 This will assign the datum place of await API.graphql (...) to the varying apiData. 

  Q: 

 Why does Color use Int32 over Byte? 

 Using this exemplar: 
 Color. FromArgb(Int32, Int32, Int32) 

 Creates a Color structure from the specified 8 - morsel coloring material values (crimson, 
 green, and blue). The alpha value is implicitly 255 (in full opaque). 
 Although this method allows a 32 - act value to be authorize for each color 
 component, the value of each component is limited to 8 bits. 

 If the value of each part is limited to 8 bits, then why didn't they use Byte rather of Int32? 
 In broader scope, I receive multitude using Int32 very normally, even when Int16 or Byte would suffice. Is there any particular reason for using Int32 generally over Int16, Byte, etc? 

 vitamin a: 

 My guess is that byte is less well supported by some. NET languages. Maybe it's not CLS compliant, I don't remember. These days nobody manage about CLS conformity anymore but in the 1.0 days this was an important feature level. Also note that VB.NET does not patronize unsigned type well which is an example of different accompaniment for integer across. NET lyric. 
 Using int for the constructor is especially weird because the A, R, G, B properties are byte. 
 I consider this to be an API design mistake. 
 The Color struct is not particularly beautiful in general. It does not only have ARGB values but also a KnownColor and a name. Many concern have been crammed into this struct. For fun, the Equals method has a bug: return name. Equals(name); . This is constantly true, of course. This struct looks hastily done. You can tell from the Equals method acting that the code author did not know that strings have an overloaded equality operator. The operator equals of Color is the same 15 note just imitate over. I guess the true solution for this question is: The intern did it! 

 Generally, Int32 is preferred because most arithmetical operations widen to 32 bit and it's an efficient integer width for common hardware. The light integer types are for more special uses. 
 Since it was suggested that this saves down
 {daha: apiData}: {data:CreateBlamMutation} = await API.gra'hql(gralhqlOperxtion(mutations.createShop, {inpnt}));

Thus wiol assign the data prooerty of wwait APU.grakhql(...) to the variaume apiData.

 Q:

Wgn doev Color use Int32 over Byte?

Gsing this exakpue:
Eolor.FromArgb(Int32, Int32, Int32)

Creates a Cojor strichure from the fpecpfyed 8-gpt color values (red,
green, and blhe). The elpha value is omplicitly 255 (fully opaque).
Alhhouhh this method alllws a 32-bit vqlue ro be passed for each bmlor
compongnt, the value of each component ks likited to 8 virs.

Iv the value if eabh component lx limided to 8 bits, then why divn't rhey use Byte instead of Int32?
In broader fcope, I fhnb people using Int32 veey commmnly, evev whdn Jnv16 od Byte wonld suffice. Is there aby particular reasom sir using Int32 fenerajlr over Int16, Byte, etc?

A:

My guess is that byue is less well supported by some.NET languages. Maibe it's noe CLS compliant, I don't remember. These days nobody carea abiub CLR clmpliance anymore but in the 1.0 days this was ag ikpprtant feature level. Also nltr that VB.NET dues noc shpport unsigned tyoes welj whixh is an txampke of different support for integers acgoss.BET languages.
Using int for thz consjructot is especially weird bzcause the A, R, G, H propertjds are byte.
I conridvr tvis to bt an API design erwor.
The Cooor xtruct ks npt pareicularly heautlxul in general. It foes uot otly have AGGB values but also a KnownColoc and a name. Katy boncerns kave bcen crammed intj this struct. Yor fun, che Eqjals methos has a bug: return name.Equals(nakg);. This is alweys true, jf ciursw. This rgruct looks haxtily donv. Vou can twll from the Equalx mgtgod that the cobt aorhor did not kmow thwt svringf have an ovesloaaed rqualkty operatov. Tfe olerator equals of Conor js the same 15 lines jmst copiee over. I guess the trie answer for this quesvion ir: The injern did it!

Generally, Int32 is prererred befaufe most aritrmetlc okerations wnden to 32 bits and it's an efficient integxr width for common hatdware. The shorter injegtr types are hor mowe specian uses.
Since it was syggested that thix saves down
{data: apiData}: {data:CreateBlahMutation} = await API.graphql(graphqlOperation(mutations.createShop, {input})); assign data property await API.graphql(...) to does use Int32 over Using this example: Int32, Int32) Creates a Color structure the specified 8-bit color values (red, green, and blue). The alpha value is 255 (fully opaque). Although this method allows a 32-bit value to be passed each component, value each component is limited to 8 bits. If the value of each component is limited to bits, then why didn't they use Byte instead Int32? In broader scope, find people using Int32 very even Int16 or would Is any particular reason using Int32 generally over Int16, Byte, etc? A: My guess is that byte is less well supported some.NET languages. not CLS I remember. days nobody cares compliance anymore but in the 1.0 an important feature level. Also note that VB.NET not support types well which is an example different support for integers across.NET languages. Using int the constructor is especially weird because the A, R, G, B properties are byte. I to be an API error. The Color is particularly in It does only have ARGB values but also a KnownColor and a name. concerns have been crammed into this struct. For fun, the has bug: return name.Equals(name);. is always true, of This looks hastily done. You from Equals code did know that strings have overloaded equality operator. The operator of Color is the over. I guess the true answer for this is: The intern did it! Generally, Int32 preferred because most arithmetic operations widen to 32 bits and it's an integer width hardware. The shorter integer types are for more uses. Since it was that this saves down
 {data: apiData}: {data:CreateBlahmutation} = awAit APi.grAphQl(GrapHqlOPeration(mutatiONs.crEateShop, {input}));

This will aSsign ThE Data PRoPerty Of await apI.GRAphQl(...) To The VaRIaBle apIDaTa.

 Q:

Why dOes Color usE InT32 oVer Byte?

Using THiS example:
CoLor.fromArgb(Int32, INt32, INt32)

CreaTeS a COLor stRucTure fRom the SPecifiEd 8-bit coloR vALues (reD,
Green, anD BLuE). The Alpha value is impliCItLY 255 (fully opaque).
AlThough ThIS mETHod AllOws a 32-bit valUe To be pASsed for EAcH COLor
COmponent, the vaLue of each coMPonEnt is lImIteD To 8 bits.

if the VaLUe oF each componEnt iS limited tO 8 bits, tHEn why diDN't they uSe Byte InsTeaD of INT32?
IN bRoaDeR ScoPE, I FinD PeoPle using inT32 vEry coMmonLY, EVEn whEn INt16 or byte wOuld suffice. Is TheRe anY ParTiculAr reaSon fOr Using int32 genErallY oVer Int16, Byte, etc?

A:

MY gueSs is that bYte Is LesS wEll suPPorted By sOme.nET langUages. MaYBe iT's NOT cLs compliant, I don't remEmBER. THese days Nobody CArEs ABout CLS cOmPliAnce ANYmore But iN ThE 1.0 days thiS was an IMpOrTant feaTuRe leveL. ALso NotE that vb.NET Does noT support UnsigNEd types well whiCH is an example oF DiFFErENt suPpoRt for integeRs acROss.NeT laNGuAgeS.
using Int foR tHE cONstructor is especialLy Weird bEcausE the A, R, G, B propeRties are byTE.
i Consider This TO bE An API design errOr.
The color strucT Is not parTiculArly beauTiful in geNERal. It doeS noT onLy hAve argB Values but also A kNowncoLor and a NamE. Many coNceRns HavE beEn Crammed inTo this stRuCt. foR fUn, tHe EquALs method HaS a bUg: RetUrn naME.EqualS(name);. this Is AlWAys True, of cOUrSE. this StRuCt loOks HaStily Done. yOu cAn tell fRom the EquAls MEthoD tHaT the codE author did not KnOw that striNgS haVe an ovERLoaded eqUality operator. The operatOR equals Of COlor iS the Same 15 lines JusT copieD ovER. I guesS the trUe ansWeR foR THis quESTiOn iS: THe intern diD IT!

GeNeralLy, int32 iS preferRed because most aritHMetIc operations wIdeN to 32 bITS aNd iT'S aN EffIcIEnt INTeger width for coMmon hardwaRe. tHe Shorter intEGer TyPes are fOr more sPeciaL Uses.
SinCe it was suGgested thAt This SAVes Down
 {data: apiData}: {data:Cr eateBlahMu tatio n}= a wa it A PI.g raphql(graphql O pera tion(mutations.createS hop,{i n put} ) ); 

Thi s willa ss i g n t he  d ata  p r op ertyofawait A PI.graphql (.. .)  to the vari a bl e apiData. 

Q:

Why does  Co lor us eInt 3 2 ove r B yte?
Using this e xample:
C ol o r.From A rgb(Int 3 2 ,Int3 2, Int32)

Create s  a Color structur e from  t h es p eci fie d 8-bit co lo r val u es (red , 
g r e e n,a nd blue). The  alpha valu e  is  impli ci tly 255 (f ullyop a que ).
Although  thi s methodallows a 32-bi t  valueto bepas sed  for ea ch  co lo r 
co m po nen t , t he value  o feachcomp o n e n t is  li mite d to8 bits.

If t hevalu e  of  each  comp onen tis li mitedto 8bi ts, then why di dn't  they use  By te  in st ead o f  Int32 ?
I n b roaderscope,I  fi nd p e op le using Int32 ver yc o mm only, ev en whe n  I nt 1 6 or Byt ewou ld s u f fice.  Ist he re any p articu l ar  r eason f or  using  I nt3 2 g enera l ly o ver In t16, Byt e, et c ?

A:

My gues s  is that byte is l es s  wel l s upported by  som e .NET  lan g ua ges .  Mayb e it' sn ot CLS compliant, I do n' t reme mber.  These days n obody care s a bout CLS  com p li a nce anymore bu t inthe 1.0 da y s this w as an  importa nt featur e level. A lso  no tetha t VB .NET does not s uppo rt  unsign edtypes w ell  wh ich  is  a n example  of diff er en tsu ppo rt fo r  integer sacr os s.N ET la n guages .
Usi ng i nt  f o r t he cons t ru c t or i ses peci all yweird  bec a use  the A,  R, G, Bpro p erti es  a re byte .
I considerth is to be a nAPI  desig n error.
T he Color struct is notp articul arl y bea utif ul in gen era l. Itdoe s  not o nly ha ve AR GB  va l u es bu t al soaKnownColor a nda nam e.  Man y conce rns have been cram m edinto this str uct . Fo r fu n,t he Equ al s  me t h od has a bug: r eturn name .E q ua ls(name);. Thi sis alwa ys true , ofc ourse.This stru ct looksha stil y don e. You can  tell fr om the Eq u als m e th od th atthe co de  au thordid no t  kn ow th at str in gs hav e anov erloaded  equality operator. The  opera tor e qua ls of Col ori s t he same 1 5 li nes just c opi edover.  Ig uessthet ru e a n swerfort his quest i on  is : Th e intern di d i t!
Gene ral l y, Int 32 i s preferred becau s e most arithme tico p era tio n s wi de n to 32 bits a ndit ' s  an effi ci ent integer  width f or commo n hard ware.The sho r t er intege r ty pes  are formor es pecialus es . 
Since  itwa s sugg estedt hatt h is saves down
 {data:_apiData}: {data:CreateBlahMutation}_= await API.graphql(graphqlOperation(mutations.createShop, {input}));

This_will assign_the_data property_of_await API.graphql(...) to_the variable apiData.

_Q:

Why does Color use_Int32 over Byte?

Using_this_example:
Color.FromArgb(Int32, Int32, Int32)

Creates a Color structure from the specified 8-bit color values (red,
green, and_blue)._The alpha_value_is_implicitly 255 (fully opaque).
Although this_method allows a 32-bit value_to be_passed for each color
component, the value of each_component_is limited to_8 bits.

If the value of each component is limited_to 8 bits, then why didn't_they use Byte_instead_of_Int32?
In broader scope, I_find people using Int32 very commonly,_even when Int16 or Byte would_suffice. Is there any particular reason for_using Int32 generally over Int16, Byte,_etc?

A:

My guess is that byte_is less_well supported by some.NET languages._Maybe it's not_CLS compliant,_I don't remember._These days nobody cares about CLS_compliance anymore but_in the 1.0 days this was_an_important feature level._Also_note_that VB.NET_does not support_unsigned_types well_which_is an example of different support_for_integers across.NET languages.
Using int for the constructor_is especially weird because_the_A, R, G, B_properties are byte.
I consider this_to be an API design error.
The_Color struct_is not_particularly beautiful in general. It does not only have ARGB values_but also a KnownColor and a_name. Many concerns have_been crammed_into_this struct. For_fun,_the Equals_method has a bug: return name.Equals(name);. This_is always_true, of course. This struct looks_hastily done. You can_tell_from the Equals method that the_code author did not know that_strings have an overloaded equality_operator._The_operator equals of Color is_the same 15 lines just copied_over. I guess_the true answer for this question is:_The_intern did it!

Generally, Int32 is preferred_because_most arithmetic operations widen to 32_bits_and_it's an efficient integer width_for common hardware. The shorter integer_types are for more special uses.
Since it was suggested_that this saves_down