id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c9000 | fmt.Errorf("argument tx in (%s x) was not regtype, "+
"instead type %T displaying as '%v' ",
name, arg, arg.SexpString(nil))
}
//Q("arrayOf arg = '%s' with type %T", args[0].SexpString(nil), args[0])
derivedType := reflect.ArrayOf(sz, rt.TypeCache)
arrayRt := NewRegisteredType(func(env *Zlisp, h *SexpHash)... | |
c9001 |
errmsg := fmt.Sprintf("err 101: cannot compare %T to %T", i, expr)
return 0, errors.New(errmsg)
} | |
c9002 | TokenQuote:
expr, err := parser.parseExpression(depth + 1)
if err != nil {
return SexpNull, err
}
return MakeList([]Sexp{parser.env.MakeSymbol("quote"), expr}), nil
case TokenCaret:
//...
}
} | |
c9003 |
stack.elements = el
stack.tos = newsize - 1
} | |
c9004 | inspected.
err = errIfPrivate(curSym.name, curStack)
if err != nil {
return SexpNull, err
}
}
// done with GET
return ret, nil
}
// invar: i < lenpath-1, so go deeper
switch x := ret.(type) {
case *SexpHash:
err = errIfPrivate(curSym.name, curStack)
if err != nil {
return Se... | |
c9005 |
return &fieldError{
fieldStack: []string{fieldName},
nestedErr: err,
}
} | |
c9006 | value := ctx.URLParam("key")
ctx.JSON(context.Map{"value": value})
})
app.Post("/reqbody", func(ctx context.Context) {
var model myModel
ctx.ReadJSON(&model)
ctx.Writef(model.Username)
})
app.Post("/hello", func(ctx context.Context) {
username := ctx.FormValue("username")
ctx.Writef("Hello %s", user... | |
c9007 | r := middleware.NewResponseRecorder(ctx.Recorder().Naive())
r.Body = bytes.NewBuffer(ctx.Recorder().Body())
r.Status = ctx.Recorder().StatusCode()
//iris recorder writes the recorded data to its original response recorder. So pass the testrecorder
// as responsewriter to after call.
middleware.After(apiCall... | |
c9008 |
amount: &Amount{val: amount},
currency: newCurrency(code).get(),
}
} | |
c9009 | m.currency.equals(om.currency)
} | |
c9010 | err != nil {
return false, err
}
return m.compare(om) == 0, nil
} | |
c9011 | mutate.calc.absolute(m.amount), currency: m.currency}
} | |
c9012 | mutate.calc.negative(m.amount), currency: m.currency}
} | |
c9013 | != nil {
return nil, err
}
return &Money{amount: mutate.calc.add(m.amount, om.amount), currency: m.currency}, nil
} | |
c9014 | != nil {
return nil, err
}
return &Money{amount: mutate.calc.subtract(m.amount, om.amount), currency: m.currency}, nil
} | |
c9015 | &Money{amount: mutate.calc.multiply(m.amount, mul), currency: m.currency}
} | |
c9016 | &Money{amount: mutate.calc.divide(m.amount, div), currency: m.currency}
} | |
c9017 | mutate.calc.round(m.amount, m.currency.Fraction), currency: m.currency}
} | |
c9018 | for i := 0; i < n; i++ {
ms[i] = &Money{amount: a, currency: m.currency}
}
l := mutate.calc.modulus(m.amount, int64(n)).val
// Add leftovers to the first parties.
for p := 0; l != 0; p++ {
ms[p].amount = mutate.calc.add(ms[p].amount, &Amount{1})
l--
}
return ms, nil
} | |
c9019 | Calculate leftover value and divide to first parties.
lo := m.amount.val - total
sub := int64(1)
if lo < 0 {
sub = -sub
}
for p := 0; lo != 0; p++ {
ms[p].amount = mutate.calc.add(ms[p].amount, &Amount{sub})
lo -= sub
}
return ms, nil
} | |
c9020 | m.currency.get()
return c.Formatter().Format(m.amount.val)
} | |
c9021 | Decimal: Decimal,
Thousand: Thousand,
Fraction: Fraction,
}
return currencies[Code]
} | |
c9022 | c.Thousand,
Grapheme: c.Grapheme,
Template: c.Template,
}
} | |
c9023 | c.Code, Fraction: 2, Grapheme: c.Code, Template: "1$"}
} | |
c9024 |
return curr
}
return c.getDefault()
} | |
c9025 | Decimal: decimal,
Thousand: thousand,
Grapheme: grapheme,
Template: template,
}
} | |
c9026 |
sa = sa[:len(sa)-f.Fraction] + f.Decimal + sa[len(sa)-f.Fraction:]
}
sa = strings.Replace(f.Template, "1", sa, 1)
sa = strings.Replace(sa, "$", f.Grapheme, 1)
// Add minus sign for negative amount.
if amount < 0 {
sa = "-" + sa
}
return sa
} | |
c9027 |
return &BloomFilter{max(1, m), max(1, k), bitset.New(m)}
} | |
c9028 |
hasher.Write(a1) // #nosec
v3, v4 := hasher.Sum128()
return [4]uint64{
v1, v2, v3, v4,
}
} | |
c9029 | := EstimateParameters(n, fp)
return New(m, k)
} | |
c9030 | }
if f.k != g.k {
return fmt.Errorf("k's don't match: %d != %d", f.m, g.m)
}
f.b.InPlaceUnion(g.b)
return nil
} | |
c9031 | {
fc := New(f.m, f.k)
fc.Merge(f) // #nosec
return fc
} | |
c9032 | for i := uint32(0); i < rounds; i++ {
binary.BigEndian.PutUint32(n1, i+uint32(n)+1)
if f.Test(n1) {
//fmt.Printf("%v failed.\n", i+uint32(n)+1)
fp++
}
}
fpRate = float64(fp) / (float64(rounds))
f.ClearAll()
return
} | |
c9033 | bool {
return f.m == g.m && f.k == g.k && f.b.Equal(g.b)
} | |
c9034 | uint(0); i < k; i++ {
locs[i] = location(h, i)
}
return locs
} | |
c9035 |
states: map[string]*State{},
events: map[string]*Event{},
}
} | |
c9036 | *StateMachine {
sm.initialState = name
return sm
} | |
c9037 | {
state := &State{Name: name}
sm.states[name] = state
return state
} | |
c9038 | {
event := &Event{Name: name}
sm.events[name] = event
return event
} | |
c9039 | := enter(value, newTx); err != nil {
value.SetState(stateWas)
return err
}
}
}
// Transition: after
for _, after := range transition.afters {
if err := after(value, newTx); err != nil {
value.SetState(stateWas)
return err
}
}
if newTx != nil {
scope := newTx.... | |
c9040 |
state.enters = append(state.enters, fc)
return state
} | |
c9041 |
state.exits = append(state.exits, fc)
return state
} | |
c9042 | append(event.transitions, transition)
return transition
} | |
c9043 | *EventTransition {
transition.froms = states
return transition
} | |
c9044 | transition.befores = append(transition.befores, fc)
return transition
} | |
c9045 | transition.afters = append(transition.afters, fc)
return transition
} | |
c9046 |
)
for _, field := range scope.PrimaryFields() {
primaryValues = append(primaryValues, fmt.Sprint(field.Field.Interface()))
}
return strings.Join(primaryValues, "::")
} | |
c9047 | scope.TableName(), GenerateReferenceKey(model, db)).Find(&changelogs)
return changelogs
} | |
c9048 |
err := c.get(spotifyURL, &user)
if err != nil {
return nil, err
}
return &user, nil
} | |
c9049 | {
v.Set("limit", strconv.Itoa(*opt.Limit))
}
if opt.Offset != nil {
v.Set("offset", strconv.Itoa(*opt.Offset))
}
if params := v.Encode(); params != "" {
spotifyURL += "?" + params
}
}
var result SavedTrackPage
err := c.get(spotifyURL, &result)
if err != nil {
return nil, err
}
return &res... | |
c9050 | c.modifyFollowers("user", true, ids...)
} | |
c9051 | c.modifyFollowers("artist", true, ids...)
} | |
c9052 | c.modifyFollowers("user", false, ids...)
} | |
c9053 | c.modifyFollowers("artist", false, ids...)
} | |
c9054 |
c.baseURL, t, strings.Join(toStringSlice(ids), ","))
var result []bool
err := c.get(spotifyURL, &result)
if err != nil {
return nil, err
}
return result, nil
} | |
c9055 | = clientID
a.config.ClientSecret = secretKey
} | |
c9056 | didn't get access code")
}
actualState := values.Get("state")
if actualState != state {
return nil, errors.New("spotify: redirect state parameter doesn't match")
}
return a.config.Exchange(a.context, code)
} | |
c9057 | a.config.Exchange(a.context, code)
} | |
c9058 | return Client{
http: client,
baseURL: baseAddress,
}
} | |
c9059 |
return nil, errors.New("spotify: oauth2 transport type not correct")
}
t, err := transport.Source.Token()
if err != nil {
return nil, err
}
return t, nil
} | |
c9060 | err := c.get(spotifyURL, &a)
if err != nil {
return nil, err
}
return &a, nil
} | |
c9061 | struct {
Albums []*FullAlbum `json:"albums"`
}
err := c.get(spotifyURL, &a)
if err != nil {
return nil, err
}
return a.Albums, nil
} | |
c9062 | c.GetAlbumTracksOpt(id, -1, -1)
} | |
c9063 | v.Encode()
if optional != "" {
spotifyURL = spotifyURL + "?" + optional
}
var result SimpleTrackPage
err := c.get(spotifyURL, &result)
if err != nil {
return nil, err
}
return &result, nil
} | |
c9064 | v.Set("offset", strconv.Itoa(*opt.Offset))
}
if params := v.Encode(); params != "" {
spotifyURL += "?" + params
}
}
var result struct {
Playlists SimplePlaylistPage `json:"playlists"`
Message string `json:"message"`
}
err := c.get(spotifyURL, &result)
if err != nil {
return "", nil,... | |
c9065 | req, err := http.NewRequest("DELETE", spotifyURL, nil)
if err != nil {
return err
}
err = c.execute(req, nil)
if err != nil {
return err
}
return nil
} | |
c9066 | c.GetPlaylistsForUserOpt(userID, nil)
} | |
c9067 | c.GetPlaylistOpt(playlistID, "")
} | |
c9068 | c.GetPlaylistTracksOpt(playlistID, nil, "")
} | |
c9069 | http.NewRequest("POST", spotifyURL, bytes.NewReader(bodyJSON))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json")
var p FullPlaylist
err = c.execute(req, &p, http.StatusCreated)
if err != nil {
return nil, err
}
return &p, err
} | |
c9070 | fmt.Sprintf("spotify:track:%s", trackID),
Positions: positions,
}
} | |
c9071 |
}
spotifyURL := fmt.Sprintf("%splaylists/%s/tracks?uris=%s",
c.baseURL, playlistID, strings.Join(trackURIs, ","))
req, err := http.NewRequest("PUT", spotifyURL, nil)
if err != nil {
return err
}
err = c.execute(req, nil, http.StatusCreated)
if err != nil {
return err
}
return nil
} | |
c9072 | := c.get(spotifyURL, &a)
if err != nil {
return nil, err
}
return &a, nil
} | |
c9073 | ","))
var a struct {
Artists []*FullArtist
}
err := c.get(spotifyURL, &a)
if err != nil {
return nil, err
}
return a.Artists, nil
} | |
c9074 |
Tracks []FullTrack `json:"tracks"`
}
err := c.get(spotifyURL, &t)
if err != nil {
return nil, err
}
return t.Tracks, nil
} | |
c9075 | will likely return a lot
// of duplicates (one for each market in which the album is available)
// - prevent this behavior by falling back to the US by default
// TODO: would this ever be the desired behavior?
values.Set("market", CountryUSA)
}
if options.Limit != nil {
values.Set("limit", strconv.I... | |
c9076 | `json:"devices"`
}
err := c.get(c.baseURL+"me/player/devices", &result)
if err != nil {
return nil, err
}
return result.PlayerDevices, nil
} | |
c9077 |
v.Set("market", *opt.Country)
}
if params := v.Encode(); params != "" {
spotifyURL += "?" + params
}
}
var result PlayerState
err := c.get(spotifyURL, &result)
if err != nil {
return nil, err
}
return &result, nil
} | |
c9078 | if err != nil {
return nil, err
}
var result CurrentlyPlaying
err = c.execute(req, &result, http.StatusNoContent)
if err != nil {
return nil, err
}
return &result, nil
} | |
c9079 | if opt.BeforeEpochMs != 0 {
v.Set("before", strconv.FormatInt(int64(opt.BeforeEpochMs), 10))
}
if opt.AfterEpochMs != 0 {
v.Set("after", strconv.FormatInt(int64(opt.AfterEpochMs), 10))
}
if params := v.Encode(); params != "" {
spotifyURL += "?" + params
}
}
result := RecentlyPlayedResult{}
err :... | |
c9080 | err
}
req, err := http.NewRequest(http.MethodPut, c.baseURL+"me/player", buf)
if err != nil {
return err
}
err = c.execute(req, nil, http.StatusNoContent)
if err != nil {
return err
}
return nil
} | |
c9081 | return err
}
}
req, err := http.NewRequest(http.MethodPut, spotifyURL, buf)
if err != nil {
return err
}
err = c.execute(req, nil, http.StatusNoContent)
if err != nil {
return err
}
return nil
} | |
c9082 | }
if params := v.Encode(); params != "" {
spotifyURL += "?" + params
}
}
req, err := http.NewRequest(http.MethodPut, spotifyURL, nil)
if err != nil {
return err
}
err = c.execute(req, nil, http.StatusNoContent)
if err != nil {
return err
}
return nil
} | |
c9083 | "position_ms": []string{strconv.FormatInt(int64(position), 10)},
},
opt,
)
} | |
c9084 | c.RepeatOpt(state, nil)
} | |
c9085 |
url.Values{
"state": []string{state},
},
opt,
)
} | |
c9086 | c.VolumeOpt(percent, nil)
} | |
c9087 | "volume_percent": []string{strconv.FormatInt(int64(percent), 10)},
},
opt,
)
} | |
c9088 | c.ShuffleOpt(shuffle, nil)
} | |
c9089 | "state": []string{strconv.FormatBool(shuffle)},
},
opt,
)
} | |
c9090 | c.modifyLibraryTracks(true, ids...)
} | |
c9091 | return c.modifyLibraryTracks(false, ids...)
} | |
c9092 | c.GetCategoryPlaylistsOpt(catID, nil)
} | |
c9093 | query := values.Encode(); query != "" {
spotifyURL += "?" + query
}
}
wrapper := struct {
Playlists SimplePlaylistPage `json:"playlists"`
}{}
err := c.get(spotifyURL, &wrapper)
if err != nil {
return nil, err
}
return &wrapper.Playlists, nil
} | |
c9094 | *TrackAttributes {
ta.floatAttributes["max_acousticness"] = acousticness
return ta
} | |
c9095 | *TrackAttributes {
ta.floatAttributes["min_acousticness"] = acousticness
return ta
} | |
c9096 | *TrackAttributes {
ta.floatAttributes["target_acousticness"] = acousticness
return ta
} | |
c9097 | *TrackAttributes {
ta.floatAttributes["max_danceability"] = danceability
return ta
} | |
c9098 | *TrackAttributes {
ta.floatAttributes["min_danceability"] = danceability
return ta
} | |
c9099 | *TrackAttributes {
ta.floatAttributes["target_danceability"] = danceability
return ta
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.